introduction

Cet article est l'article du 13ème jour du Calendrier de l'Avent Puri Puri Appliance 2019.

Dans cet article, l'auteur, qui travaille en tant qu'ingénieur ML, présentera comment utiliser la plate-forme AI de GCP, qu'il utilise habituellement, pour exécuter le moteur de prédiction IA en une heure.

Qu'est-ce que AI Platform?

Récemment, je pense que le nombre d'entreprises essayant de fabriquer des produits à l'aide de l'IA a augmenté. Cependant, si vous essayez réellement de créer un moteur de prédiction IA, cela demandera beaucoup de travail, comme la définition des ressources GPU pour qu'elles soient disponibles et leur mise à l'échelle. Le service qui résout ces problèmes est ʻAIPlatfrom`.

AI Platform est l'un des services fournis par Google Could Platform. Site Web officiel d'AI Platform Il est très efficace lors de la mise en œuvre de produits utilisant l'apprentissage automatique, car il est facile de mettre en œuvre l'apprentissage et la prédiction à l'aide du GPU. Python est pris en charge comme langage, et le framework peut utiliser scikit-learn, TensorFlow, XGBoost, et ainsi de suite.

Configuration requise pour GCP

Cet article utilise les services GCP suivants.

AIPlatform
GoogleCloudStorage

Veuillez préparer un compte pouvant faire fonctionner chaque service.

Déployer le modèle Keras

Créons un modèle simple à l'aide de Keras et déployons-le.

Les étapes suivantes sont requises pour le déploiement.

--Définir et former des modèles Keras.

Téléchargez le modèle appris sur GCS (Google Could Storage). --Définissez l'espace de noms du modèle avec AIPlatform. --Associez l'espace de nom du modèle défini dans AIPlatform au modèle téléchargé dans GCS.

Par exemple, créons et déployons un modèle qui "prédit de manière régressive" x ^ 2 "pour la" valeur d'entrée x ". Voici l'exemple de code.

keras_model_deploy.py

`keras_model_deploy.py`


from tensorflow.python.keras.models import Sequential, Model
from tensorflow.python.keras.layers import Dense
import tensorflow as tf
import numpy as np


def create_data():
    data_size = 1000 
    x = [i for i in range(data_size)]
    y = [i**2 for i in range(data_size)]
    return x, y


def create_model() -> Model:
    model = Sequential()
    model.add(Dense(32, activation=tf.nn.relu, input_shape=(1,)))
    model.add(Dense(1))
     
    optimizer = tf.train.RMSPropOptimizer(0.001)
    model.compile(loss='mse', optimizer=optimizer, metrics=['mae'])
    return model


def run_train(x: np.ndarray, y: np.ndarray, model: Model) -> Model:
    history = model.fit(
        x, 
        y, 
        batch_size=1000,
        epochs=100,
        verbose=1,
    )
    return model


def save_model(model: Model) -> None:
    tf.keras.experimental.export_saved_model(
        model,
        "gs://your-buckets/models/sample_model",  #Spécifiez le chemin de GCS à enregistrer
        serving_only=False
    )


if __name__ == "__main__":
    x, y = create_data()
    model = create_model()  
    model = run_train(x, y, model)
    print(model.predict([2]))
    save_model(model)

Vous pouvez enregistrer le modèle sur GCS en utilisant tf.keras.experimental.export_saved_model. Cependant, ce n'est que si la spécification du chemin commence par gs: //, et si vous spécifiez un chemin normal, il sera enregistré dans local.

Exécutez ce code.

output.txt

Epoch 1/100
1000/1000 [==============================] - 0s 62us/sample - loss: 199351844864.0000 - mean_absolute_error: 332684.8750
Epoch 2/100
1000/1000 [==============================] - 0s 1us/sample - loss: 199338442752.0000 - mean_absolute_error: 332671.3750
Epoch 3/100
1000/1000 [==============================] - 0s 1us/sample - loss: 199328612352.0000 - mean_absolute_error: 332661.5938
Epoch 4/100
1000/1000 [==============================] - 0s 1us/sample - loss: 199320403968.0000 - mean_absolute_error: 332653.3438
Epoch 5/100
1000/1000 [==============================] - 0s 1us/sample - loss: 199313096704.0000 - mean_absolute_error: 332646.0312
Epoch 6/100
1000/1000 [==============================] - 0s 1us/sample - loss: 199306379264.0000 - mean_absolute_error: 332639.2812
Epoch 7/100
1000/1000 [==============================] - 0s 1us/sample - loss: 199300087808.0000 - mean_absolute_error: 332633.0000
Epoch 8/100
1000/1000 [==============================] - 0s 1us/sample - loss: 199294124032.0000 - mean_absolute_error: 332627.0000
Epoch 9/100
1000/1000 [==============================] - 0s 1us/sample - loss: 199288389632.0000 - mean_absolute_error: 332621.2500
・
・
・
Epoch 100/100
1000/1000 [==============================] - 0s 1us/sample - loss: 198860079104.0000 - mean_absolute_error: 332191.8438
[[3.183104]]

La précision du modèle est médiocre, mais nous avons confirmé qu'il renvoie correctement les résultats de la prédiction.

À partir de là, nous allons opérer et déployer sur la console GCP. (Le même travail peut être effectué à partir de la commande en utilisant la commande gcloud, mais je ne l'introduirai pas cette fois.)

Commençons par créer un espace de noms de modèle sur AI Platform.

Allez dans l'onglet Modèles AIPlatform et cliquez sur «Créer un modèle».

Définissez le nom et la région.

Les paramètres du journal sont définis ici. Veuillez noter que ce paramètre ne peut pas être modifié.

Ensuite, secouez la version du modèle. Ici, lien avec le modèle téléchargé sur GCS.

Sélectionnez un modèle et cliquez sur «Nouvelle version».

Après avoir spécifié le nom de la version et l'environnement d'exploitation du modèle, spécifiez le chemin du SavedModel téléchargé sur GCS. Vous pouvez également définir ici les ressources (type de machine) à utiliser. Sélectionnez la ressource requise en fonction de votre application.

Après avoir spécifié tous les paramètres, lorsque vous créez une version, le modèle sera installé sur AI Platform. Lorsque vous installez un modèle, AI Platform fournit une API pour effectuer des prédictions à l'aide de ce modèle.

Vous êtes maintenant prêt à accéder à l'API de prédiction.

** Mise en garde ** AIPlatform continuera toujours à utiliser les ressources GPU lorsque le modèle est installé. Veuillez noter que cela entraînera une facturation sans faire de `demande prédictive! !! '' Nous vous recommandons de supprimer les modèles que vous n'utilisez pas!

Obtenez le résultat de la prédiction

Je souhaite faire une demande de prédiction sur un modèle déployé sur AI Platform et obtenir le résultat.

Lorsque vous faites une requête en utilisant python, il est facile d'utiliser googleapiclient.

L'authentification est requise lors d'une demande, mais cela peut être résolu en spécifiant le chemin d'un fichier d'informations d'identification tel qu'un compte de service dans la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS.

`predict.py`


from googleapiclient import discovery

project = "your-project-id"
model = "model_sample"

def predict(instances):
    service = discovery.build('ml', 'v1', cache_discovery=False)
    url = f"projects/{project}/models/{model}"

    response = service.projects().predict(
        name=url,
        body={'instances': [instances]}
    ).execute()

    return response


if __name__ == "__main__":
    features = [2]
    prediction = predict(features) 
    print(prediction)

Pour des spécifications détaillées de l'argument «nom» de «prédire» et «corps», consultez la formule de ici. Veuillez vérifier la référence.

Lorsqu'il est exécuté, le résultat de la prédiction peut être obtenu comme suit.

output

{'predictions': [{'dense_1': [3.183104]}]}

Vous avez maintenant construit un moteur de prédiction! (La précision est médiocre, mais ...)

À la fin

Dans l'article, l'apprentissage a été effectué dans l'environnement local, mais vous pouvez également apprendre à utiliser les ressources GPU sur AI Platform. Je pense que ce sera une arme puissante lors de la fabrication de produits utilisant l'IA.

Cette fois, j'ai créé un moteur de prédiction utilisant un modèle Keras simple en une heure. J'espère que ça t'aide.

[PYTHON] Créez le moteur de prédiction Keras AI en 1 heure avec GCP