En este tutorial, caminamos por la cara abrazada Rastreador Paso a paso, explorando cómo podemos rastrear los experimentos a nivel local, limpio e intuitivo. Comenzamos instalando Trackio en Google Colab, preparando un conjunto de datos y configurando múltiples ejecuciones de entrenamiento con diferentes hiperparámetros. En el camino, registramos métricas, visualizamos matrices de confusión como tablas e incluso importamos los resultados de un archivo CSV para demostrar la flexibilidad de la herramienta. Al ejecutar todo en un solo cuaderno, obtenemos experiencia práctica con el tablero liviano pero poderoso de Trackio, viendo que nuestros resultados se actualizan en tiempo real. Mira el Códigos completos aquí.
!pip -q install -U trackio scikit-learn pandas matplotlib
import os, time, math, json, random, pathlib, itertools, tempfile
from dataclasses import dataclass
import numpy as np
import pandas as pd
from sklearn.datasets import make_classification
from sklearn.linear_model import SGDClassifier
from sklearn.metrics import accuracy_score, log_loss, confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import trackioComenzamos instalando las bibliotecas requeridas, incluidas Trackio, Scikit-Learn, Pandas y Matplotlib. Luego importamos módulos de pitón esenciales y utilidades de aprendizaje automático para que podamos generar datos, modelos de trenes y rastrear experimentos sin problemas. Mira el Códigos completos aquí.
def make_dataset(n=12000, n_informative=18, n_classes=3, seed=42):
X, y = make_classification(
n_samples=n, n_features=32, n_informative=n_informative, n_redundant=0,
n_classes=n_classes, random_state=seed, class_sep=2.0
)
X_train, X_temp, y_train, y_temp = trn_tst_split(X, y, test_size=0.3, random_state=seed)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=seed)
ss = StandardScaler().fit(X_train)
return ss.transform(X_train), y_train, ss.transform(X_val), y_val, ss.transform(X_test), y_test
def batches(X, y, bs, shuffle=True, seed=0):
idx = np.arange(len(X))
if shuffle:
rng = np.random.default_rng(seed)
rng.shuffle(idx)
for i in range(0, len(X), bs):
j = idx[i:i+bs]
yield X[j], y[j]
def cm_table(y_true, y_pred):
cm = confusion_matrix(y_true, y_pred)
df = pd.DataFrame(cm, columns=[f"pred_{i}" for i in range(cm.shape[0])])
df.insert(0, "true", [f"true_{i}" for i in range(cm.shape[0])])
return dfCreamos funciones auxiliares que nos permiten generar un conjunto de datos sintético, dividirlo en entrenamiento, validación y conjuntos de pruebas, por lote los datos para capacitación y construyendo tablas de matriz de confusión. De esta manera, configuramos todo el trabajo de base que necesitamos para una capacitación y evaluación de modelos suaves. Mira el Códigos completos aquí.
@dataclass
class RunCfg:
lr: float = 0.05
l2: float = 1e-4
epochs: int = 8
batch_size: int = 256
seed: int = 0
project: str = "trackio-demo"
def train_and_log(cfg: RunCfg, Xtr, ytr, Xva, yva):
run = trackio.init(
project=cfg.project,
name=f"sgd_lr{cfg.lr}_l2{cfg.l2}",
config={"lr": cfg.lr, "l2": cfg.l2, "epochs": cfg.epochs, "batch_size": cfg.batch_size, "seed": cfg.seed}
)
clf = SGDClassifier(loss="log_loss", penalty="l2", alpha=cfg.l2, learning_rate="constant",
eta0=cfg.lr, random_state=cfg.seed)
n_classes = len(np.unique(ytr))
clf.partial_fit(Xtr[:cfg.batch_size], ytr[:cfg.batch_size], classes=np.arange(n_classes))
global_step = 0
for epoch in range(cfg.epochs):
epoch_losses = []
for xb, yb in batches(Xtr, ytr, cfg.batch_size, shuffle=True, seed=cfg.seed + epoch):
clf.partial_fit(xb, yb)
probs = np.clip(clf.predict_proba(xb), 1e-9, 1 - 1e-9)
loss = log_loss(yb, probs, labels=np.arange(n_classes))
epoch_losses.append(loss)
global_step += 1
val_probs = np.clip(clf.predict_proba(Xva), 1e-9, 1 - 1e-9)
val_preds = np.argmax(val_probs, axis=1)
val_loss = log_loss(yva, val_probs, labels=np.arange(n_classes))
val_acc = accuracy_score(yva, val_preds)
train_loss = float(np.mean(epoch_losses))
trackio.log({
"epoch": epoch,
"train_loss": train_loss,
"val_loss": val_loss,
"val_accuracy": val_acc
})
if epoch in {cfg.epochs//2, cfg.epochs-1}:
df = cm_table(yva, val_preds)
tbl = trackio.Table(dataframe=df)
trackio.log({f"val_confusion_epoch_{epoch}": tbl})
time.sleep(0.15)
trackio.finish()
return val_accDefinimos una clase de configuración para almacenar nuestra configuración de capacitación y una función Train_and_Log que ejecuta un clasificador SGD mientras registra métricas para TrackIO. Hacemos un seguimiento de las pérdidas, la precisión e incluso las matrices de confusión en las épocas, lo que nos brinda información numérica y visual sobre el rendimiento del modelo en tiempo real. Mira el Códigos completos aquí.
Xtr, ytr, Xva, yva, Xte, yte = make_dataset()
grid = list(itertools.product([0.01, 0.03, 0.1], [1e-5, 1e-4, 1e-3]))
results = []
for lr, l2 in grid:
acc = train_and_log(RunCfg(lr=lr, l2=l2, seed=123), Xtr, ytr, Xva, yva)
results.append({"lr": lr, "l2": l2, "val_acc": acc})
summary = pd.DataFrame(results).sort_values("val_acc", ascending=False).reset_index(drop=True)
best = summary.iloc[0].to_dict()
run = trackio.init(project="trackio-demo", name="summary", config={"note": "sweep results"})
trackio.log({"best_val_acc": float(best["val_acc"]), "best_lr": float(best["lr"]), "best_l2": float(best["l2"])})
trackio.log({"sweep_table": trackio.Table(dataframe=summary)})
trackio.finish()Ejecutamos un pequeño barrido de hiperparameter sobre la tasa de aprendizaje y L2, y registramos la precisión de validación de cada ejecución. Luego resumimos los resultados en una tabla, registramos la mejor configuración para TrackIO y finalizamos la ejecución de resumen. Mira el Códigos completos aquí.
csv_path = "/content/trackio_demo_metrics.csv"
df_csv = pd.DataFrame({
"step": np.arange(10),
"metric_x": np.linspace(1.0, 0.2, 10),
"metric_y": np.linspace(0.1, 0.9, 10),
})
df_csv.to_csv(csv_path, index=False)
trackio.import_csv(csv_path, project="trackio-csv-import")
app = trackio.show(project="trackio-demo")
# trackio.init(project="myproj", space_id="username/trackio-demo-space")
Simulamos un archivo CSV de métricas, lo importamos a Trackio como un nuevo proyecto y luego lanzamos el tablero para nuestro proyecto principal. Esto nos permite ver tanto las ejecuciones registradas como los datos externos uno al lado del otro en la interfaz interactiva de Trackio. Mira el Códigos completos aquí.
Descripción general del tablero de trackio
En conclusión, experimentamos cómo TrackIO Streamlines experimenta el seguimiento sin la complejidad de la infraestructura pesada o las configuraciones de API. No solo registramos y comparamos las ejecuciones, sino que también capturamos resultados estructurados, importamos datos externos y lanzamos un tablero interactivo directamente dentro de Colab. Con este flujo de trabajo, vemos cómo Trackio nos permite mantenernos organizados, monitorear el progreso de manera efectiva y tomar mejores decisiones durante la experimentación. Este tutorial nos brinda una base sólida para integrar Trackio en nuestros propios proyectos de aprendizaje automático sin problemas.
Mira el Códigos completos aquí. No dude en ver nuestro Página de Github para tutoriales, códigos y cuadernos. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro Subreddit de 100k+ ml y suscribirse a Nuestro boletín.
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como empresario e ingeniero visionario, ASIF se compromete a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, MarktechPost, que se destaca por su cobertura profunda de noticias de aprendizaje automático y de aprendizaje profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el público.