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.
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.
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.
smcli new project name)smcli build)smcli push)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".
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.
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