Búsqueda de sitios web

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.