Préparez un format de projet d'apprentissage automatique et exécutez-le dans SageMaker

Bonjour, c'est Ninomiya de LIFULL CO., LTD.

Dans un projet d'apprentissage automatique, après une analyse réussie et une évaluation de la précision du modèle, il doit être mis à disposition avec succès dans les systèmes existants. A cette époque, il était difficile pour notre équipe de répartir les rôles des ingénieurs en charge de l'implémentation.

Viser à l'état que «Si un scientifique des données le crée dans ce format, il peut être facilement incorporé!», Wrap Amazon SageMaker et à usage général dans une certaine mesure. Nous avons préparé un format de développement et des outils qui peuvent être utilisés comme standard.

Qu'est-ce qu'Amazon Sage Maker?

Amazon SageMaker fournit à tous les développeurs et spécialistes des données les moyens de créer, former et déployer des modèles d'apprentissage automatique. Amazon SageMaker est un service entièrement géré qui couvre l'ensemble du flux de travail d'apprentissage automatique. Étiquetez et préparez vos données, sélectionnez des algorithmes, entraînez votre modèle, ajustez et optimisez le déploiement, faites des prédictions et effectuez. Vous pouvez mettre votre modèle en production avec moins d'efforts et de frais.

En tant que fonctions principales, si vous préparez une image Docker selon une spécification spécifique, vous pouvez utiliser les fonctions suivantes.

Lisez la documentation officielle et l'article de @ taniyam (même équipe que moi) pour les spécifications sur la préparation de votre propre image Docker avec SageMaker.

Format de projet d'apprentissage automatique

Tout d'abord, j'ai demandé au data scientist de préparer la structure de répertoires suivante.

.
├── README.md
├── Dockerfile
├── config.yml
├── pyproject.toml (fichier de configuration de poésie)
├── script
│   └── __init__.py
└── tests
    └── __init__.py

Le processus principal est écrit dans script / __ init __. Py, et le script est le suivant. Ceci est la bibliothèque préparée par simple_sagemaker_manager.

import pandas as pd
from typing import List
from pathlib import Path
from sklearn import tree
from simple_sagemaker_manager.image_utils import AbstractModel


def train(training_path: Path) -> AbstractModel:
    """Apprenez.

    Args:
        training_path (Path):Répertoire avec fichiers csv
    
    Returns:
        Model:Objet de modèle qui hérite de AbstractModel
        
    """
    train_data = pd.concat([pd.read_csv(fname, header=None) for fname in training_path.iterdir()])
    train_y = train_data.iloc[:, 0]
    train_X = train_data.iloc[:, 1:] 

    # Now use scikit-learn's decision tree classifier to train the model.
    clf = tree.DecisionTreeClassifier(max_leaf_nodes=None)
    clf = clf.fit(train_X, train_y)
    return Model(clf)


class Model(AbstractModel):
    """La méthode de sérialisation est décrite dans AbstractModel.
    """

    def predict(self, matrix: List[List[float]]) -> List[List[str]]:
        """Traitement des inférences.

        Args:
            matrix (List[List[float]]):Données de table

        Returns:
            list:Résultat d'inférence

        """
        #Le résultat renvoyé ici sera la réponse de l'API d'inférence.
        return [[x] for x in self.model.predict(pd.DataFrame(matrix))]

ʻAbstractModel a la définition suivante, et le résultat de l'appel de la méthode save(résultat de la sérialisation par pickle) est sauvegardé, et ceci est utilisé comme modèle lors de l'exécution du lot d'apprentissage (utilisé par le système SageMaker). Il est enregistré dans S3. De plus, la méthode de sérialisation peut être modifiée en remplaçantsave et load`.

import pickle
from abc import ABC, abstractmethod
from dataclasses import dataclass


@dataclass
class AbstractModel(ABC):
    model: object

    @classmethod
    def load(cls, model_path):
        #Enregistrez le modèle pendant le lot d'entraînement
        with open(model_path / 'model.pkl', 'rb') as f:
            model = pickle.load(f)
        return cls(model)

    def save(self, model_path):
        #Charger le modèle lors de l'inférence
        with open(model_path / 'model.pkl', 'wb') as f:
            pickle.dump(self.model, f)

    @abstractmethod
    def predict(self, json):
        pass

J'essaye de fonctionner avec cli en me référant à des projets comme la [poésie] de Python (https://poetry.eustace.io/). Le flux de développement de l'image Docker de SageMaker est le suivant.

De plus, j'ai rendu possible la modification du Dockerfile car certaines bibliothèques de machine learning ne peuvent être installées qu'avec Anaconda, j'ai donc reçu une demande "Je veux que vous le remplaciez par une autre image que l'image officielle de Python3".

Gestion de l'exécution de SageMaker

Il est difficile d'exécuter boto3 directement, j'ai donc préparé une bibliothèque enveloppée ici aussi. Il y a beaucoup d'opérations, mais dans de nombreux projets, nous avons trois choses à faire: "apprendre le modèle" et "exécuter un travail de conversion par lots OR qui configure une API d'inférence", nous avons donc une interface qui le rend facile à comprendre.

from simple_sagemaker_manager.executor import SageMakerExecutor
from simple_sagemaker_manager.executor.classes import TrainInstance, TrainSpotInstance, Image


client = SageMakerExecutor()

#Lors de l'apprentissage avec une instance normale
model = client.execute_batch_training(
    instance=TrainInstance(
        instance_type='ml.m4.xlarge',
        instance_count=1,
        volume_size_in_gb=10,
        max_run=100
    ),
    image=Image(
        name="decision-trees-sample",
        uri="xxxxxxxxxx.dkr.ecr.ap-northeast-1.amazonaws.com/decision-trees-sample:latest"
    ),
    input_path="s3://xxxxxxxxxx/DEMO-scikit-byo-iris",
    output_path="s3://xxxxxxxxxx/output",
    role="arn:aws:iam::xxxxxxxxxx"
)


#Lors de l'apprentissage avec une instance ponctuelle
model = client.execute_batch_training(
    instance=TrainSpotInstance(
        instance_type='ml.m4.xlarge',
        instance_count=1,
        volume_size_in_gb=10,
        max_run=100,
        max_wait=1000
    ),
    image=Image(
        name="decision-trees-sample",
        uri="xxxxxxxxxx.dkr.ecr.ap-northeast-1.amazonaws.com/decision-trees-sample:latest"
    ),
    input_path="s3://xxxxxxxxxx/DEMO-scikit-byo-iris",
    output_path="s3://xxxxxxxxxxx/output",
    role="arn:aws:iam::xxxxxxxxxxxxx"
)

L'API d'inférence est créée comme suit. Les points que j'ai élaborés sont les suivants.

from simple_sagemaker_manager.executor import SageMakerExecutor
from simple_sagemaker_manager.executor.classes import EndpointInstance, Model

client = SageMakerExecutor()


#Lors du déploiement d'un modèle spécifique
#Si vous spécifiez plusieurs modèles pour les modèles, un modèle de pipeline sera créé et utilisé.
client.deploy_endpoint(
    instance=EndpointInstance(
        instance_type='ml.m4.xlarge',
        initial_count=1,
        initial_variant_wright=1
    ),
    models=[
        Model(
            name='decision-trees-sample-191028-111309-538454',
            model_arn='arn:aws:sagemaker:ap-northeast-1:xxxxxxxxxx',
            image_uri='xxxxxxxxxx.dkr.ecr.ap-northeast-1.amazonaws.com/decision-trees-sample:latest',
            model_data_url='s3://xxxxxxxxxx/model.tar.gz'
        )
    ],
    name='sample-endpoint',
    role="arn:aws:iam::xxxxxxxxxx"
)

# execute_batch_Vous pouvez également passer le résultat de la formation
model = client.execute_batch_training(
    #L'argument est omis
) 

client.deploy_endpoint(
    instance=EndpointInstance(
        instance_type='ml.m4.xlarge',
        initial_count=1,
        initial_variant_wright=1
    ),
    models=[model],
    name='sample-endpoint',
    role="arn:aws:iam::xxxxxxxxxx"
)

Les noms autres que les points de terminaison (tels que l'apprentissage des travaux par lots) sont automatiquement ajoutés avec la chaîne d'heure actuelle pour éviter la duplication. Cependant, seul le point de terminaison a le comportement de "mise à jour s'il y en a un avec le même nom" pour améliorer la commodité.

De plus, bien qu'elle soit omise, la méthode de travail de conversion par lots est implémentée de la même manière.

Défis futurs

Je l'ai implémenté de cette manière, et maintenant je l'utilise dans la mise en œuvre de certains projets. Cependant, certains problèmes n'ont pas encore été mis en œuvre, et il y a encore d'autres problèmes au sein de l'équipe.

De plus, si vous l'utilisez réellement au sein de l'équipe, certaines parties ne sont pas faciles à utiliser.Je vais donc essayer de résoudre ces problèmes et de rendre le projet d'apprentissage automatique plus efficace.

Recommended Posts

Préparez un format de projet d'apprentissage automatique et exécutez-le dans SageMaker
Jusqu'à ce que vous créiez un environnement d'apprentissage automatique avec Python sur Windows 7 et que vous l'exécutiez
Écrivons un programme Python et exécutons-le
Exécutez un pipeline de machine learning avec Cloud Dataflow (Python)
Créer un environnement Python d'apprentissage automatique sur Mac OS
Installez Docker sur Arch Linux et exécutez-le à distance
Windows10 (x64) Créer nativement un environnement d'apprentissage automatique
Configurer des bibliothèques Python et d'apprentissage automatique sur Ubuntu
Comment dessiner de manière interactive un pipeline d'apprentissage automatique avec scikit-learn et l'enregistrer au format HTML
Dans un environnement Linux, créez un package NuGet à partir d'un projet C # et chargez-le dans un autre projet
Créer un environnement d'étude d'apprentissage automatique Python avec macOS Sierra
Créer un environnement d'apprentissage automatique sur Mac (pyenv, deeplearning, opencv)
Créez un environnement d'apprentissage automatique scikit-learn avec VirtualBox et Ubuntu
Créer un environnement d'apprentissage automatique
Apprentissage automatique et optimisation mathématique
Comment installer OpenCV sur Cloud9 et l'exécuter en Python
J'ai créé un script POST pour créer un problème sur Github et l'enregistrer dans le projet
Importance de l'apprentissage automatique et de l'apprentissage par mini-lots
Installez et exécutez Dropbox sur Ubuntu 20.04
Classification et régression dans l'apprentissage automatique
Exécutez Matplotlib sur un conteneur Docker
Analyse inverse du modèle d'apprentissage automatique
Exécutez headless-chrome sur une image basée sur Debian
Exécutez TensorFlow2 sur le serveur VPS
Démarrez avec l'apprentissage automatique avec SageMaker
Procédure d'apprentissage automatique de base: ② Préparer les données
Une histoire d'essayer d'exécuter JavaScripthon sur Windows et d'abandonner.
Installez le module ROS et ROS pour Roomba sur Raspberry Pi 3 et essayez de l'exécuter
[Mémo personnel] Obtenez des données sur le Web et faites-en un DataFrame