Donner vie à l'apprentissage automatique avec TensorFlow

En tant que développeur JavaScript, se lancer dans l'apprentissage automatique n'est pas aussi intimidant qu'il y paraît. Bien qu'il soit techniquement possible de tout gérer avec les packages Node.js, l'écosystème Python ML est tout simplement trop riche et bien établi pour être ignoré. De plus, Python est un plaisir de travailler avec. Il est donc logique d’utiliser Python pour le gros du travail sur le backend. Une fois que votre modèle est prêt, vous pouvez l'exporter dans un format convivial et le charger sur le client pour exécuter des prédictions.

Générer un modèle

Dans cet article, nous allons créer un modèle pour prédire la popularité d'un artiste en fonction de son nombre de followers sur Twitter.

La première étape consiste à mettre la main sur un ensemble de données. Pour ce projet, nous utiliserons un fichier Artists.csv qui ressemble à ceci :

twitter_followers,popularity,handle
111024636,94,justinbieber
107920365,91,rihanna
106599902,89,katyperry
95307659,97,taylorswift13
66325495,87,selenagomez
66325135,71,selenagomez
60943147,83,jtimberlake
54815915,82,britneyspears
53569307,85,shakira

Comme vous pouvez le voir, il y a ici deux valeurs clés : twitter_followers et popularité. Cela nous prépare bien pour un modèle de séquence, où x sera twitter_followers et y sera la popularité.

Modèle de séquence est l'une des options les plus simples pour créer un modèle. Bien que le choix dépende en fin de compte du cas d’utilisation spécifique, je reste simple et m’en tiens à cette approche pour le moment.

Construire le back-end

Lorsque vous créez un modèle, vous devez effectuer certaines tâches de base :

• Nettoyer ou normaliser les données
• Répartir les données entre Formation (80 %) et Tests (20 %)
• Choisissez un modèle ainsi que des paramètres tels que l'optimiseur et la fonction de perte
• Entraîner le modèle (ajustement)
• Évaluer le modèle
• Enregistrer le modèle

Le code suivant vous donne un bon aperçu de ces tâches, même s'il ne constitue pas une image complète. Vous pouvez consulter le code complet sur Github.

Python : Premiers pas avec TensorFlow

def get_model(x, y):
    x_normalized = layers.Normalization(
        axis=None,
    )
    x_normalized.adapt(np.array(x))

    model = tensorflow.keras.Sequential([x_normalized, layers.Dense(units=1)])

    model.compile(
        optimizer=tensorflow.keras.optimizers.Adam(learning_rate=0.1),
        loss="mean_squared_error",
    )

    model.fit(
        x,
        y,
        epochs=2,
        verbose=0,
        validation_split=0.2,
    )

    return model

def main:
  train_features, test_features, train_labels, test_labels = split_data(dataset)

  model = get_model(
      train_features["twitter_followers"],
      train_labels,
  )

  test_loss = model.evaluate(
      test_features["twitter_followers"], test_labels, verbose=2
  )

  model.export("./saved_model")

Comme vous pouvez le voir, le code Python est assez simple. Il existe une fonction principale qui gère le fractionnement des données, l'obtention du modèle, son évaluation et enfin son enregistrement.

En résumé, voici les étapes essentielles pour créer un modèle. Mais soyons réalistes : construire un modèle qui fonctionne réellement est à la fois un art et une science. Mon objectif ici est simplement de montrer à quel point il peut être facile de démarrer avec Python. Cependant, la création d'un modèle performant nécessite beaucoup de choses : disposer d'un ensemble de données solide, nettoyer et normaliser vos données, choisir le modèle et les paramètres appropriés et disposer de la puissance de calcul nécessaire pour l'entraîner. Toutes ces tâches nécessitent un sérieux investissement de temps et d’efforts !

Consommer le modèle sur le frontend

Maintenant que notre modèle est formé et enregistré, il est temps de l'intégrer au frontend. Cette étape consiste à charger le modèle dans un format adapté au Web, afin de pouvoir exécuter des prédictions directement dans le navigateur. Que vous utilisiez TensorFlow.js ou une autre bibliothèque, l'intégration du machine learning dans votre application Web ouvre un monde de possibilités. Voyons comment procéder !

TensorFlow propose un package npm appelé tensorflowjs_converter qui permet de convertir les modèles enregistrés en JSON et binaire.

tensorflowjs_converter --input_format=tf_saved_model model/saved_model out/public

• tf_saved_model : Il s'agit du format utilisé pour enregistrer le modèle.
• model/saved_model : Il s'agit du répertoire dans lequel le modèle a été enregistré lors de l'exécution du code Python.
• out/public : il s'agit du répertoire de sortie dans lequel les fichiers frontend-friendly sont enregistrés. La structure des dossiers ressemblera à ceci :

ls -la out/public

group1-shard1of1.bin
model.json

Cette configuration facilite l'accès aux fichiers nécessaires à votre application Web.

Javascript : utiliser TensorFlowJS

Vous pouvez consulter le code complet sur Github.

const model = await tensorflow.loadGraphModel("model.json");

const getPopularity = (followers) => {
  const followers = 1_000;
  const normalized = followers;
  const x = tensorflow.tensor(normalized).reshape([-1, 1]);

  const result = model.predict(x);
  const values = result.arraySync();

  const y = values[0][0].toFixed(2) * 100;
  const popularity = y;

  return popularity;
};

Comme mentionné précédemment, ce modèle vise à « prédire la popularité » en fonction du nombre d'abonnés sur Twitter. Bien que cela puisse sembler un exemple simple, il montre efficacement comment générer un modèle sur le backend et l'utiliser sur le frontend.

Jetez un œil à la façon dont getPopularity traite un peu l'entrée, mais la ligne clé est model.predict(x), qui utilise le modèle pour prédire une valeur (y) en fonction de l'entrée x.

Rendez-vous sur la page de démonstration et essayez quelques identifiants Twitter. C'est une façon amusante de voir comment le modèle prédit la popularité en fonction du nombre de followers.

Conclusion

TensorFlow est une bibliothèque géniale qui fournit des outils pour le développement back-end et front-end. Tout développeur JavaScript peut se lancer dans la création d'un modèle à l'aide de Python ou d'un langage similaire, puis importer facilement ce modèle dans l'interface pour exécuter des prédictions.

Bien que l'apprentissage automatique soit un vaste domaine qui nécessite beaucoup de connaissances, des outils comme TensorFlow aident à combler le fossé entre les développeurs de logiciels et d'apprentissage automatique. Cela rend le voyage beaucoup plus fluide pour ceux qui cherchent à intégrer le ML dans leurs projets !