Cree una aplicación de ciencia de datos con Python en 10 sencillos pasos
Aprenda a crear una aplicación de ciencia de datos con Python, utilizando Scikit-Learn y FastAPI, paso a paso.
¿Quiere mejorar sus habilidades en ciencia de datos? Crear una aplicación de ciencia de datos es una excelente manera de aprender más.
La creación de una aplicación de ciencia de datos implica varios pasos, desde la recopilación y el preprocesamiento de datos hasta el entrenamiento de modelos y la entrega de predicciones a través de una API. Este tutorial paso a paso lo guiará a través del proceso de creación de una aplicación de ciencia de datos sencilla.
Usaremos Python, scikit-learn y FastAPI para entrenar un modelo de aprendizaje automático y crear una API para cumplir con sus predicciones. Para simplificar las cosas, utilizaremos el conjunto de datos de vino integrado de scikit-learn. ¡Empecemos!
▶️ Puedes encontrar el código en GitHub.
Paso 1: configurar el entorno
Deberías tener instalada una versión reciente de Python. Luego, instale las bibliotecas necesarias para construir el modelo de aprendizaje automático y la API para realizar las predicciones:
$ pip3 install fastapi uvicorn scikit-learn pandas
Nota: asegúrese de instalar las bibliotecas necesarias en un entorno virtual para el proyecto.
Paso 2: cargar el conjunto de datos
Usaremos el conjunto de datos de vinos de scikit-learn. Carguemos el conjunto de datos y convirtámoslo en un marco de datos de pandas para facilitar la manipulación:
# model_training.py
from sklearn.datasets import load_wine
import pandas as pd
def load_wine_data():
wine_data = load_wine()
df = pd.DataFrame(data=wine_data.data, columns=wine_data.feature_names)
df['target'] = wine_data.target # Adding the target (wine quality class)
return df
Paso 3: explorar el conjunto de datos
Antes de continuar, es una buena práctica explorar un poco el conjunto de datos.
# model_training.py
if __name__ == "__main__":
df = load_wine_data()
print(df.head())
print(df.describe())
print(df['target'].value_counts()) # Distribution of wine quality classes
Aquí, realizamos una exploración preliminar del conjunto de datos mostrando las primeras filas, generando estadísticas resumidas y verificando la distribución de las clases de salida.
Paso 4: preprocesamiento de datos
A continuación, preprocesaremos el conjunto de datos. Dividimos el conjunto de datos en conjuntos de entrenamiento y prueba, y escalamos las funciones.
La función preprocess_data
hace precisamente eso:
# model_training.py
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
def preprocess_data(df):
X = df.drop('target', axis=1) # Features
y = df['target'] # Target (wine quality)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=27)
# Feature scaling
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
return X_train_scaled, X_test_scaled, y_train, y_test
El escalado de funciones con StandardScaler garantiza que todas las funciones contribuyan por igual al entrenamiento del modelo.
Paso 5: entrenar el modelo de regresión logística
Ahora entrenemos un modelo de LogisticRegression con los datos preprocesados y guardemos el modelo en un archivo pickle. La siguiente función train_model
hace eso:
# model_training.py
from sklearn.linear_model import LogisticRegression
import pickle
def train_model(X_train, y_train):
model = LogisticRegression(random_state=42)
model.fit(X_train, y_train)
# Save the trained model using pickle
with open('classifier.pkl', 'wb') as f:
pickle.dump(model, f)
return model
Paso 6: Evaluación del modelo
Una vez entrenado el modelo, evaluamos su rendimiento calculando la precisión en el conjunto de prueba. Para hacerlo, definamos la función evaluate_model
así:
# model_training.py
from sklearn.metrics import accuracy_score
def evaluate_model(model, X_test, y_test):
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")
if __name__ == "__main__":
df = load_wine_data()
X_train_scaled, X_test_scaled, y_train, y_test = preprocess_data(df)
model = train_model(X_train_scaled, y_train)
evaluate_model(model, X_test_scaled, y_test)
Cuando ejecuta el script Python: los datos se cargan, se preprocesan, el modelo se entrena y se evalúa. Al ejecutar el script ahora se obtiene:
Accuracy: 0.98
Paso 7: Configurar FastAPI
Ahora, configuraremos una aplicación FastAPI básica que realizará predicciones utilizando nuestro modelo entrenado.
# app.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "A Simple Prediction API"}
En este paso, configuramos una aplicación FastAPI básica y definimos un punto final raíz. Esto crea un servidor web simple que puede responder a solicitudes HTTP.
Puede ejecutar la aplicación FastAPI con:
uvicorn app:app --reload
Vaya a http://127.0.0.1:8000 para ver el mensaje.
Paso 8: cargar el modelo en FastAPI
Cargaremos el modelo previamente entrenado dentro de FastAPI para hacer predicciones.
Sigamos adelante y definamos una función para cargar el modelo de regresión logística previamente entrenado dentro de nuestra aplicación FastAPI.
# app.py
import pickle
def load_model():
with open('model/classifier.pkl', 'rb') as f:
model = pickle.load(f)
return model
Esto significa que nuestro modelo está listo para hacer predicciones cuando se reciben solicitudes.
Paso 9: creación del punto final de predicción
Definiremos un punto final para aceptar las características del vino como entrada y devolver la clase de calidad del vino prevista.
Definir modelo de datos de entrada
Nos gustaría crear un punto final de predicción que acepte datos de características del vino en formato JSON. El modelo de datos de entrada, definido con Pydantic, valida los datos entrantes.
# app.py
from pydantic import BaseModel
class WineFeatures(BaseModel):
alcohol: float
malic_acid: float
ash: float
alcalinity_of_ash: float
magnesium: float
total_phenols: float
flavanoids: float
nonflavanoid_phenols: float
proanthocyanins: float
color_intensity: float
hue: float
od280_od315_of_diluted_wines: float
proline: float
Punto final de predicción
Cuando se recibe una solicitud, la API utiliza el modelo cargado para predecir la clase de vino en función de las características proporcionadas.
# app.py
@app.post("/predict")
def predict_wine(features: WineFeatures):
model = load_model()
input_data = [[
features.alcohol, features.malic_acid, features.ash, features.alcalinity_of_ash,
features.magnesium, features.total_phenols, features.flavanoids,
features.nonflavanoid_phenols, features.proanthocyanins, features.color_intensity,
features.hue, features.od280_od315_of_diluted_wines, features.proline
]]
prediction = model.predict(input_data)
return {"prediction": int(prediction[0])}
Paso 10: Probar la aplicación localmente
Puede volver a ejecutar la aplicación ejecutando:
uvicorn app:app --reload
Para probar la aplicación, envíe una solicitud POST al punto final /predict
con datos de características del vino:
curl -X POST "http://127.0.0.1:8000/predict" \
-H "Content-Type: application/json" \
-d '{
"alcohol": 13.0,
"malic_acid": 2.14,
"ash": 2.35,
"alcalinity_of_ash": 20.0,
"magnesium": 120,
"total_phenols": 3.1,
"flavanoids": 2.6,
"nonflavanoid_phenols": 0.29,
"proanthocyanins": 2.29,
"color_intensity": 5.64,
"hue": 1.04,
"od280_od315_of_diluted_wines": 3.92,
"proline": 1065
}'
Es importante realizar pruebas localmente para garantizar que la API funcione según lo previsto antes de cualquier implementación. Entonces, probamos la aplicación enviando una solicitud POST al punto final de predicción con datos de características del vino de muestra y obtenemos la clase predicha.
{"prediction":0}
Concluyendo
Hemos creado una aplicación de ciencia de datos simple pero funcional.
Después de construir un modelo de aprendizaje automático con scikit-learn, utilizamos FastAPI para crear una API que acepta entradas del usuario y devuelve predicciones. Puede intentar crear modelos más complejos, agregar funciones y mucho más.
Como siguiente paso, puede explorar diferentes conjuntos de datos, modelos o incluso implementar la aplicación en producción. Lea Una guía práctica para implementar modelos de aprendizaje automático para obtener más información.