Intégrations de plateformes d'apprentissage automatique #1 : poids et biais

Le suivi des expériences est un aspect essentiel du développement de l'apprentissage automatique, car il permet aux praticiens de gérer et de suivre l'avancement de leurs expériences de manière efficace. Le suivi des expériences implique l'enregistrement et la surveillance de divers facteurs, tels que les performances du modèle, les hyperparamètres et les données d'entraînement, afin de mieux comprendre les performances du modèle d'apprentissage automatique.

Difficultés liées à la gestion des expériences

La gestion des expériences et le suivi des résultats peuvent être une tâche difficile pour les praticiens de l'apprentissage automatique en raison de la complexité des modèles, des grandes quantités de données impliquées et de la variété d'outils et de cadres utilisés dans le développement de l'apprentissage automatique. Voici quelques-uns des principaux défis auxquels sont confrontés les praticiens dans la gestion des expériences et le suivi des résultats :

1. Reproductibilité : La reproduction des expériences est essentielle pour vérifier les résultats et garantir que les modèles fonctionnent bien dans des scénarios réels. Cependant, la reproduction d'expériences peut s'avérer difficile, en particulier lorsqu'il s'agit de modèles complexes, de cadres multiples et d'environnements informatiques différents.
2. Évolutivité : Les praticiens de l'apprentissage automatique travaillent souvent avec de grands ensembles de données et, par conséquent, les modèles de formation peuvent être un processus fastidieux qui nécessite une puissance de calcul importante. La gestion des expériences et le suivi des résultats à grande échelle nécessitent des outils et une infrastructure capables de gérer de grandes quantités de données et de calculs.
3. Collaboration : La collaboration est essentielle dans le développement de l'apprentissage automatique, mais la gestion des expériences et le suivi des résultats entre plusieurs membres de l'équipe peuvent s'avérer difficiles. Cela nécessite une infrastructure robuste pour partager les données, le code et les résultats des expériences et garantir que tout le monde a accès aux mêmes ressources.
4. Gestion des données : Les modèles d'apprentissage automatique s'appuient largement sur les données, et la gestion efficace des données est essentielle à la réussite du modèle. Cependant, la gestion des données implique divers défis, tels que le nettoyage des données, l'étiquetage des données et la gestion des versions des données, qui peuvent être complexes et chronophages.
5. Optimisation des hyperparamètres : Trouver les meilleurs hyperparamètres pour un modèle peut être un processus complexe et itératif qui implique la réalisation de plusieurs expériences avec différents hyperparamètres. La gestion de ces expériences et le suivi des résultats peuvent être longs et complexes.

Exploration des caractéristiques des poids et des biais

Poids et biais (W&B) est une plateforme conçue pour aider les praticiens de l'apprentissage automatique à gérer et à suivre leurs expériences de manière efficace. Il fournit une suite d'outils pour le suivi des expériences, la visualisation et la collaboration, permettant aux praticiens de développer plus facilement des modèles d'apprentissage automatique robustes et évolutifs.

Les principales caractéristiques et avantages de la plateforme W&B sont les suivants :

1. Suivi des expériences : W&B permet aux utilisateurs de suivre leurs expériences en enregistrant automatiquement les hyperparamètres, les métriques et les artefacts de sortie du modèle. Cela permet aux praticiens de suivre leurs expériences et de comparer facilement différents modèles et hyperparamètres.
2. Visualisations : W&B fournit une suite d'outils de visualisation qui permettent aux utilisateurs de visualiser leurs expériences et leurs résultats. Il s'agit notamment de visualisations 3D, de matrices de confusion et de diagrammes de dispersion. Cela aide les praticiens à mieux comprendre leurs données et à identifier des modèles et des tendances dans les résultats des expériences.
3. Collaboration : W&B facilite la collaboration avec les membres de l'équipe en fournissant des fonctionnalités permettant de partager les expériences, les données et les résultats. Il fournit également un contrôle de version pour le code et les données, garantissant ainsi que tout le monde travaille avec les mêmes ressources.
4. Intégration : W&B peut être facilement intégré à un large éventail de frameworks d'apprentissage automatique, notamment TensorFlow, PyTorch, Keras et Scikit-learn. Cela permet aux praticiens d'utiliser W&B avec leurs flux de travail et leurs frameworks existants, sans nécessiter de modifications importantes de leur processus de développement.
5. Organisation : W&B propose des fonctionnalités permettant d'organiser des expériences, telles que des projets, des exécutions et des balises. Cela facilite la gestion et le suivi des expériences entre plusieurs membres de l'équipe et projets.

Guide étape par étape : configurer facilement les poids et les biais

La configuration de W&B pour le suivi des expériences comporte plusieurs étapes :

1. Ouvrez un compte W&B : La première étape consiste à créer un compte gratuit sur le site Web de W&B. Cela peut être fait en visitant le site Web et en suivant le processus d'inscription.
2. Installation de la bibliothèque W&B : Après avoir créé un compte, l'étape suivante consiste à installer la bibliothèque W&B dans l'environnement de développement. La bibliothèque W&B peut être installée à l'aide de pip ou conda, selon les préférences de l'utilisateur et son environnement de développement.
3. Initialiser W&B : Une fois la bibliothèque installée, l'utilisateur doit initialiser W&B dans le code en appelant le et .init () fonction. Cette fonction initialise la bibliothèque W&B et configure une nouvelle exécution.
4. Métriques de journalisation : l'utilisateur peut enregistrer des mesures telles que la perte et la précision pendant l'entraînement en appelant le wandb.log () fonction. Cette fonction prend un dictionnaire de métriques en entrée et les enregistre dans le tableau de bord W&B.
5. Enregistrer les hyperparamètres : l'utilisateur peut également enregistrer des hyperparamètres tels que le taux d'apprentissage et la taille des lots en appelant le wandb.config fonction. Cette fonction prend un dictionnaire d'hyperparamètres en entrée et les enregistre dans le tableau de bord W&B.
6. Visualisations du journal : Enfin, l'utilisateur peut enregistrer des visualisations telles que des images et des tracés en appelant wandb.log () fonctionner avec les données de visualisation appropriées. W&B propose une large gamme d'outils de visualisation, notamment des visualisations 3D, des matrices de confusion et des diagrammes de dispersion, entre autres.

Exemple :

Voici un exemple montrant comment enregistrer des métriques, des modèles, des hyperparamètres et des visualisations à l'aide de W&B :

import wandb
importer numpy en tant que nl
importer matplotlib.pyplot en tant que plt
importer tensorflow en tant que tf

# Étape 1 : Initialiser W&B
wandb.init (projet="mon-projet »)

# Étape 2 : Enregistrer les hyperparamètres
configuration = {
« taux d'apprentissage » : 0,001,
« taille du lot » : 32,
« époques » : 10
}
wandb.config.update (configuration)

# Étape 3 : Formez le modèle et enregistrez les métriques
modèle = tf.Keras.Models.Sequential ([
tf.Keras.Layers.Dense (10, activation='relu', input_shape= (10,)),
tf.Keras.Layers.Dense (1)
])
model.compile (optimizer=tf.keras.optimizers.adam (config ['learning_rate']),
loss=tf.keras.losses.MeanSquaredError (),
metrics= [tf.keras.metrics.MeanAbsoluteError ()])
pour une époque dans la plage (config ['epochs']) :
#... maquette de train...
history = model.fit (x_train, y_train, batch_size=config ['batch_size'])
perte = history.history ['perte'] [-1]
mae = history.history ['erreur_absolute_moyenne'] [-1]
wandb.log ({"epoch » : époque, « loss » : perte, « mae » : mae})

# Étape 4 : Visualisations du journal et modèle
x = np.linspace (0, 10, 100)
y = np.sin (x)
figure, ax = plt.subplots ()
ax.plot (x, y)
wandb.log ({"my_plot » : WandB.image (fig)})
wandb.save ('mon_modèle.h5')

# Étape 5 : Terminer la course
et b.finish ()

c

Intégration fluide : l'approche de TrueFoundry en matière de poids et de biais

TrueFoundry s'intègre parfaitement au registre de modèles Weights & Biases pour vous permettre de déployer des modèles enregistrés dans Weights & Biases sur votre cluster Kubernetes à l'aide de TrueFoundry.

📌

En plus d'utiliser Weights & Biases pour la gestion des modèles et le suivi des expériences, vous pouvez également utiliser le suivi des expériences MLFoundy de Truefoundry.

📌

Vous pouvez également suivre le code ci-dessous via le carnet de colab suivant :
Carnet Colab

Étape 1 - Installation et configuration :

• Installer wandb

pip install wandb -Qu

• Connectez-vous à votre compte W&B

import wandb
et b.login ()

• Installez Servicefoundry

pip install -U « servicefoundry »

• Connectez-vous à Truefoundry

connexion sfy

Étape 2 - Entraînez et enregistrez le modèle :

Nous utiliserons d'abord et .init () pour initialiser le projet
Ensuite, nous allons entraîner notre modèle de machine learning et l'enregistrer en tant que fichier joblib
Ensuite, nous enregistrerons notre fichier joblib dans wandb via et .save ()

import wandb
depuis sklearn.datasets, importez load_iris
depuis sklearn.model_selection, importez train_test_split
depuis sklearn.linear_model import LogisticRegression
depuis sklearn.metrics import classification_report
importer joblib

# Initialiser W&B
wandb.init (project="régression logistique de l'iris »)

# Chargez et prétraitez les données
X, y = load_iris (AS_FRAME=True, Return_X_Y=True)
X = x.Renommer (colonnes= {
« longueur du sépale (cm) » : « sepal_length »,
« largeur du sépale (cm) » : « sepal_width »,
« longueur du pétale (cm) » : « longueur du pétale »,
« largeur du pétale (cm) » : « largeur_du pétale »,
})

X_train, X_test, y_train, y_test = train_test_split (
X, y, test_size=0,2, état_aléatoire=42, stratifié=y
)

# Initialiser le modèle
clf = LogisticRegression (solveur = « liblinear »)

# Ajuster le modèle
clf.fit (X_train, y_train)

# Evaluer le modèle
pression = clf.predict (X_test)

# Enregistrez le modèle et les mesures d'évaluation dans W&B
joblib.dump (clf, « modèle.joblib »)
wandb.save (« modèle.joblib »)

# Terminez la course
et b.finish ()

Étape 3 - Créez une application d'inférence et un fichier de dépendances :

Nous allons devoir créer deux fichiers à déployer sur truefoundry, un app.py un fichier contenant le code de notre application, et un requirements.txt fichier qui contient nos dépendances.

.
─ app.py
─ deploy.py
・─ requirements.txt


c

• app.py :
  Ici, vous devez passer l'argument suivant dans et b.restore () : <name_of_saved_file> et « nom d'utilisateur/project/run_id »
  Par exemple : wandb.restore (« model.joblib », « adityajha-tfy/iris-logistic-regression/00r5xvyv »)

système d'importation
import wandb
importer joblib
importer des pandas au format pdf
depuis fastapi import FastAPI

wandb.login (key=os.environ ["WANDB_API_KEY"])

# Récupérez le modèle auprès de W&B
model_joblib = sandb.restore ()
« modèle.joblib »,
run_path="adityajha-tfy/iris-logistic-regression/00r5xvyy »,
)

modèle = joblib.load (model_joblib.name)

# Chargez le modèle
app = FastAPI (root_path=os.getenv (« TFY_SERVICE_ROOT_PATH »))

@app .post (« /predict »)
def predict (
sepal_length : flottant, sepal_width : flottant, petal_length : flottant, petal_width : flottant
) :
données = dict (
longueur_sépal=longueur_sépalaise,
largeur_sépal=largeur_sépal,
longueur_pétale=longueur_pétale,
largeur_pétale=largeur_pétale,
)
prédiction = int (model.predict (PD.DataFrame ([données])) [0])
return {« prédiction » : prédiction}

• requirements.txt :

fastapi
joblib
engourdi
pandas
scikit-learn
luvicorne
wandb

Étape 4 - Utilisez le SDK Python de Truefoundry et configurez le déploiement

• deploy.py :

importer argparse
journalisation des importations
depuis servicefoundry import Build, PythonBuild, Service, Resources, Port

# Configurer l'enregistreur
Logging.basicConfig (niveau = Logging.info)

# Configurer l'analyseur d'arguments
analyseur = ArgParse.ArgumentParser ()
parser.add_argument (« --workspace_fqn », obligatoire = vrai, type = str)
parser.add_argument (« --wandb_api_key », obligatoire = vrai, type = str)
arguments = analyseur.parse_args ()

service = Service (
nom = « fastapi »,
image=Construire (
build_spec=PythonBuild (
command="application uvicorn : app --port 8000 --host 0.0.0.0",
requirements_path= » requirements.txt «,
)
),
ports= [
Port (
port = 8000
host="ml-deploy-aditya-ws-8000.demo.truefoundry.com »,
)
],
Resources=Ressources (
requête_processeur = 0,25,
limite_processeur = 0,5,
demande_mémoire=200,
limite_mémoire = 400,
demande de stockage_éphémère = 200,
limite_de_stockage_éphémère = 400,
),
env= {
« WANDB_API_KEY » : args.wandb_API_key
}
)
service.deploy (workspace_fqn=args.workspace_fqn)

Étape 5 - Déployez votre service via Truefoundry

Exécutez la commande suivante et transmettez votre

• FAQ de l'espace de travail : que vous pouvez trouver dans le tableau de bord
• Clé d'API Wandb

<Your Workspace FQN><Your Wandb API Key>python deploy.py --workspace_fqn «" --wandb_api_key "»

Et voilà ! ! ! Dans les journaux, vous trouverez le tableau de bord de votre service déployé. Ensuite, dans le coin supérieur droit, vous trouverez le point de terminaison de vos applications déployées.

True Foundry est un PaaS de déploiement de machine learning sur Kubernetes destiné à accélérer les flux de travail des développeurs tout en leur offrant une flexibilité totale dans les tests et le déploiement de modèles, tout en garantissant une sécurité et un contrôle complets à l'équipe Infra. Grâce à notre plateforme, nous permettons aux équipes de machine learning de déployer et surveiller des modèles en 15 minutes avec une fiabilité à 100 %, une évolutivité et la possibilité de revenir en arrière en quelques secondes, ce qui leur permet de réduire les coûts et de mettre les modèles en production plus rapidement, ce qui permet de réaliser une véritable valeur commerciale.