Les grands modèles de langage, également connus sous le nom de modèles de base, ont gagné en popularité dans le domaine de la apprentissage automatique. Ces des modèles sont pré-formés sur de grands ensembles de données, ce qui leur permet de bien performer sur une variété de tâches sans nécessiter autant de données de formation. Découvrez remark vous pouvez facilement déployer un modèle de base pré-formé à l’aide de DataRobot MLOps capacités, puis mettre le modèle en manufacturing. En tirant parti de la puissance d’un modèle pré-entraîné, vous pouvez économiser du temps et des ressources tout en obtenant des performances élevées dans vos purposes d’apprentissage automatique.
Que sont les grands modèles de langage ?
La création de modèles de base est l’un des développements clés dans le domaine des grands modèles de langage qui suscite beaucoup d’enthousiasme et d’intérêt parmi les scientifiques des données et ingénieurs en apprentissage automatique. Ces modèles sont formés sur des quantités massives de données textuelles à l’aide d’algorithmes d’apprentissage en profondeur. Ils ont la capacité de générer un langage de kind humain cohérent et pertinent dans un contexte donné et de traiter et de comprendre le langage naturel à un niveau que l’on pensait auparavant unimaginable. En conséquence, ils ont le potentiel de révolutionner la façon dont nous interagissons avec les machines et de résoudre un massive éventail de problèmes d’apprentissage automatique.
Ces développements ont permis aux chercheurs de créer des modèles qui peuvent effectuer un massive éventail de traitement du langage naturel tâches telles que la traduction automatique, le résumé, la réponse aux questions et même la génération de dialogue. Ils peuvent également être utilisés pour des tâches créatives, telles que la génération de texte réaliste, qui peuvent être utiles pour une variété d’purposes, telles que la génération de descriptions de produits ou la création d’articles de presse.
Dans l’ensemble, les développements récents dans les grands modèles de langage sont très excitants et ont le potentiel d’améliorer considérablement notre capacité à résoudre les problèmes d’apprentissage automatique et à interagir avec les machines de manière plus naturelle et intuitive.
Premiers pas avec les modèles de langage à l’aide de Hugging Face
Comme de nombreux praticiens de l’apprentissage automatique le savent déjà, un moyen easy de démarrer avec des modèles de langage consiste à utiliser Hugging Face. Le hub de modèles Hugging Face est une plate-forme offrant une assortment de modèles pré-formés qui peuvent être facilement téléchargés et utilisés pour un massive éventail de tâches de traitement du langage naturel.
Pour démarrer avec un modèle de langage du hub de modèles Hugging Face, il vous suffit d’installer la bibliothèque Hugging Face dans votre ordinateur transportable native ou Blocs-notes DataRobot si c’est ce que vous utilisez. Si vous exécutez déjà vos expériences sur l’interface graphique de DataRobot, vous pouvez même l’ajouter en tant que tâche personnalisée.
Une fois installé, vous pouvez choisir un modèle qui correspond à vos besoins. Vous pouvez ensuite utiliser le modèle pour effectuer des tâches telles que la génération, la classification et la traduction de texte. Les modèles sont faciles à utiliser et peuvent être adaptés à vos besoins spécifiques, ce qui en fait un outil puissant pour résoudre une variété de problèmes de traitement du langage naturel.
Si vous ne souhaitez pas configurer un environnement d’exécution native, vous pouvez démarrer avec un bloc-notes Google Colab sur un environnement d’exécution CPU/GPU/TPU, télécharger votre modèle et obtenir les prédictions du modèle en quelques lignes seulement.
Par exemple, commencer avec un modèle BERT pour la réponse aux questions (bert-large-uncased-whole-word-masking-finetuned-squad) est aussi easy que d’exécuter ces lignes :
!pip set up transformers==4.25.1
from transformers import AutoTokenizer, TFBertForQuestionAnswering
MODEL = "bert-large-uncased-whole-word-masking-finetuned-squad"
tokenizer = AutoTokenizer.from_pretrained(MODEL)
mannequin = TFBertForQuestionAnswering.from_pretrained(MODEL)Déploiement de modèles de langage en manufacturing
Après avoir essayé certains modèles, éventuellement les affiner pour vos cas d’utilisation spécifiques et les avoir préparés pour la manufacturing, vous aurez besoin d’un environnement de service pour héberger vos artefacts. En plus d’un environnement pour servir le modèle, vous devrez surveiller ses performances, sa santé, ses données et sa dérive de prédiction, ainsi qu’un moyen easy de le recycler sans perturber vos workflows de manufacturing et vos purposes en aval qui consomment la sortie de votre modèle.
C’est là que le DataRobot MLOps entre en jeu. Les companies DataRobot MLOps fournissent une plate-forme pour l’hébergement et le déploiement de packages de modèles personnalisés dans divers frameworks ML tels que PyTorch, Tensorflow, ONNX et sk-learn, permettant aux organisations d’intégrer facilement leurs modèles pré-formés dans leurs purposes existantes et de les utiliser pour leur entreprise. besoins.
Pour héberger un modèle de langage pré-formé sur les companies DataRobot MLOps, il vous suffit de télécharger le modèle sur la plateforme, de créer son environnement d’exécution avec vos packages de dépendance personnalisés et de le déployer sur les serveurs DataRobot. Votre déploiement sera prêt dans quelques minutes, puis vous pourrez envoyer vos requêtes de prédiction à votre level de terminaison de déploiement et profiter de votre modèle en manufacturing.
Bien que vous puissiez effectuer toutes ces opérations à partir de l’interface utilisateur DataRobot, nous allons vous montrer ici remark mettre en œuvre le flux de travail de bout en bout, à l’aide de l’API Datarobot dans un environnement de bloc-notes. Alors, commençons!
Vous pouvez suivre ce tutoriel en créant un nouveau bloc-notes Google Colab ou en copiant notre bloc-notes depuis notre Référentiel communautaire DataRobot et exécuter le bloc-notes copié sur Google Colab.
Installer les dépendances
!pip set up transformers==4.25.1 datarobot==3.0.2
from transformers import AutoTokenizer, TFBertForQuestionAnswering
import numpy as npTéléchargez le modèle BERT de HuggingFace sur l’environnement de l’ordinateur transportable
MODEL = "bert-large-uncased-whole-word-masking-finetuned-squad"
tokenizer = AutoTokenizer.from_pretrained(MODEL)
mannequin = TFBertForQuestionAnswering.from_pretrained(MODEL)
BASE_PATH = "/content material/datarobot_blogpost"
tokenizer.save_pretrained(BASE_PATH)
mannequin.save_pretrained(BASE_PATH)
Déployer sur DataRobot
Créez le script d’inférence (glue), c’est-à-dire. le fichier customized.py.
Ce script d’inférence (fichier customized.py) sert de ciment entre vos artefacts de modèle et l’exécution du modèle personnalisé dans DataRobot. Si c’est la première fois que vous créez un modèle personnalisé sur DataRobot MLOps, notre référentiel public sera un glorious level de départ, avec de nombreux autres exemples de modèles de modèles dans différents frameworks ML et pour différents sorts de modèles, tels que la classification binaire ou multiclasse, la régression, la détection d’anomalies ou des modèles non structurés comme celui que nous allons construire dans notre exemple .
%%writefile $BASE_PATH/customized.py
"""
Copyright 2021 DataRobot, Inc. and its associates.
All rights reserved.
That is proprietary supply code of DataRobot, Inc. and its associates.
Launched below the phrases of DataRobot Instrument and Utility Settlement.
"""
import json
import os.path
import os
import tensorflow as tf
import pandas as pd
from transformers import AutoTokenizer, TFBertForQuestionAnswering
import io
def load_model(input_dir):
tokenizer = AutoTokenizer.from_pretrained(input_dir)
tf_model = TFBertForQuestionAnswering.from_pretrained(
input_dir, return_dict=True
)
return tf_model, tokenizer
def log_for_drum(msg):
os.write(1, f"n{msg}n".encode("UTF-8"))
def _get_answer_in_text(output, input_ids, idx, tokenizer):
answer_start = tf.argmax(output.start_logits, axis=1).numpy()(idx)
answer_end = (tf.argmax(output.end_logits, axis=1) + 1).numpy()(idx)
reply = tokenizer.convert_tokens_to_string(
tokenizer.convert_ids_to_tokens(input_ids(answer_start:answer_end))
)
return reply
def score_unstructured(mannequin, knowledge, question, **kwargs):
world model_load_duration
tf_model, tokenizer = mannequin
# Assume batch enter is distributed with mimetype:"textual content/csv"
# Deal with as single prediction enter if no mimetype is about
is_batch = kwargs("mimetype") == "textual content/csv"
if is_batch:
input_pd = pd.read_csv(io.StringIO(knowledge), sep="|")
input_pairs = record(zip(input_pd("summary"), input_pd("query")))
begin = time.time()
inputs = tokenizer.batch_encode_plus(
input_pairs, add_special_tokens=True, padding=True, return_tensors="tf"
)
input_ids = inputs("input_ids").numpy()
output = tf_model(inputs)
responses = ()
for i, row in input_pd.iterrows():
reply = _get_answer_in_text(output, input_ids(i), i, tokenizer)
response = {
"summary": row("summary"),
"query": row("query"),
"reply": reply,
}
responses.append(response)
pred_duration = time.time() - begin
to_return = json.dumps(
{
"predictions": responses,
"pred_duration": pred_duration,
}
)
else:
data_dict = json.masses(knowledge)
summary, query = data_dict("summary"), data_dict("query")
begin = time.time()
inputs = tokenizer(
query,
summary,
add_special_tokens=True,
padding=True,
return_tensors="tf",
)
input_ids = inputs("input_ids").numpy()(0)
output = tf_model(inputs)
reply = _get_answer_in_text(output, input_ids, 0, tokenizer)
pred_duration = time.time() - begin
to_return = json.dumps(
{
"summary": summary,
"query": query,
"reply": reply,
"pred_duration": pred_duration,
}
)
return to_returnCréer le fichier d’exigences
%%writefile $BASE_PATH/necessities.txt
transformersCharger les artefacts de modèle et le script d’inférence dans DataRobot
import datarobot as dr
def deploy_to_datarobot(folder_path, env_name, model_name, descr):
API_TOKEN = "YOUR_API_TOKEN" #Please discuss with https://docs.datarobot.com/en/docs/platform/account-mgmt/acct-settings/api-key-mgmt.html to get your token
dr.Consumer(token=API_TOKEN, endpoint="https://app.datarobot.com/api/v2/")
onnx_execution_env = dr.ExecutionEnvironment.record(search_for=env_name)(0)
custom_model = dr.CustomInferenceModel.create(
identify=model_name,
target_type=dr.TARGET_TYPE.UNSTRUCTURED,
description=descr,
language="python"
)
print(f"Creating customized mannequin model on {onnx_execution_env}...")
model_version = dr.CustomModelVersion.create_clean(
custom_model_id=custom_model.id,
base_environment_id=onnx_execution_env.id,
folder_path=folder_path,
maximum_memory=4096 * 1024 * 1024,
)
print(f"Created {model_version}.")
variations = dr.CustomModelVersion.record(custom_model.id)
sorted_versions = sorted(variations, key=lambda v: v.label)
latest_version = sorted_versions(-1)
print("Constructing the execution surroundings with dependency packages...")
build_info = dr.CustomModelVersionDependencyBuild.start_build(
custom_model_id=custom_model.id,
custom_model_version_id=latest_version.id,
max_wait=3600,
)
print(f"Setting construct accomplished with {build_info.build_status}.")
print("Creating mannequin deployment...")
default_prediction_server = dr.PredictionServer.record()(0)
deployment = dr.Deployment.create_from_custom_model_version(latest_version.id,
label=model_name,
description=descr,
default_prediction_server_id=default_prediction_server.id,
max_wait=600,
significance=None)
print(f"{deployment} is prepared!")
return deploymentCréer le déploiement du modèle
deployment = deploy_to_datarobot(BASE_PATH,
"Keras",
"blog-bert-tf-questionAnswering",
"Pretrained BERT mannequin, fine-tuned on SQUAD for query answering")Tester avec des requêtes de prédiction
Le script suivant est conçu pour faire des prédictions par rapport à votre déploiement, et vous pouvez saisir le même script en ouvrant votre compte DataRobot, en accédant au Déploiements ouvrez le déploiement que vous venez de créer, accédez à l’onglet Prédictions onglet, puis ouvrez l’onglet Code de script de l’API de prédiction -> Distinctive part.
Cela ressemblera à l’exemple ci-dessous où vous verrez vos propres API_KEY et DATAROBOT_KEY remplis.
"""
Utilization:
python datarobot-predict.py <input-file> (mimetype) (charset)
This instance makes use of the requests library which you'll set up with:
pip set up requests
We extremely advocate that you just replace SSL certificates with:
pip set up -U urllib3(safe) certifi
"""
import sys
import json
import requests
API_URL = 'https://mlops-dev.dynamic.orm.datarobot.com/predApi/v1.0/deployments/{deployment_id}/predictionsUnstructured'
API_KEY = 'YOUR_API_KEY'
DATAROBOT_KEY = 'YOUR_DATAROBOT_KEY'
# Do not change this. It's enforced server-side too.
MAX_PREDICTION_FILE_SIZE_BYTES = 52428800 # 50 MB
class DataRobotPredictionError(Exception):
"""Raised if there are points getting predictions from DataRobot"""
def make_datarobot_deployment_unstructured_predictions(knowledge, deployment_id, mimetype, charset):
"""
Make unstructured predictions on knowledge supplied utilizing DataRobot deployment_id supplied.
See docs for particulars:
https://app.datarobot.com/docs/predictions/api/dr-predapi.html
Parameters
----------
knowledge : bytes
Bytes knowledge learn from supplied file.
deployment_id : str
The ID of the deployment to make predictions with.
mimetype : str
Mimetype describing knowledge being despatched.
If mimetype begins with 'textual content/' or equal to 'software/json',
knowledge might be decoded with supplied or default(UTF-8) charset
and handed into the 'score_unstructured' hook carried out in customized.py supplied with the mannequin.
In case of different mimetype values knowledge is handled as binary and handed with out decoding.
charset : str
Charset ought to match the contents of the file, if file is textual content.
Returns
-------
knowledge : bytes
Arbitrary knowledge returned by unstructured mannequin.
Raises
------
DataRobotPredictionError if there are points getting predictions from DataRobot
"""
# Set HTTP headers. The charset ought to match the contents of the file.
headers = {
'Content material-Sort': '{};charset={}'.format(mimetype, charset),
'Authorization': 'Bearer {}'.format(API_KEY),
'DataRobot-Key': DATAROBOT_KEY,
}
url = API_URL.format(deployment_id=deployment_id)
# Make API request for predictions
predictions_response = requests.put up(
url,
knowledge=knowledge,
headers=headers,
)
_raise_dataroboterror_for_status(predictions_response)
# Return uncooked response content material
return predictions_response.content material
def _raise_dataroboterror_for_status(response):
"""Increase DataRobotPredictionError if the request fails together with the response returned"""
strive:
response.raise_for_status()
besides requests.exceptions.HTTPError:
err_msg = '{code} Error: {msg}'.format(
code=response.status_code, msg=response.textual content)
elevate DataRobotPredictionError(err_msg)
def datarobot_predict_file(filename, deployment_id, mimetype="textual content/csv", charset="utf-8"):
"""
Return an exit code on script completion or error. Codes > 0 are errors to the shell.
Additionally helpful as a utilization demonstration of
`make_datarobot_deployment_unstructured_predictions(knowledge, deployment_id, mimetype, charset)`
"""
knowledge = open(filename, 'rb').learn()
data_size = sys.getsizeof(knowledge)
if data_size >= MAX_PREDICTION_FILE_SIZE_BYTES:
print((
'Enter file is just too massive: {} bytes. '
'Max allowed measurement is: {} bytes.'
).format(data_size, MAX_PREDICTION_FILE_SIZE_BYTES))
return 1
strive:
predictions = make_datarobot_deployment_unstructured_predictions(knowledge, deployment_id, mimetype, charset)
return predictions
besides DataRobotPredictionError as exc:
pprint(exc)
return None
def datarobot_predict(input_dict, deployment_id, mimetype="software/json", charset="utf-8"):
"""
Return an exit code on script completion or error. Codes > 0 are errors to the shell.
Additionally helpful as a utilization demonstration of
`make_datarobot_deployment_unstructured_predictions(knowledge, deployment_id, mimetype, charset)`
"""
knowledge = json.dumps(input_dict).encode(charset)
data_size = sys.getsizeof(knowledge)
if data_size >= MAX_PREDICTION_FILE_SIZE_BYTES:
print((
'Enter file is just too massive: {} bytes. '
'Max allowed measurement is: {} bytes.'
).format(data_size, MAX_PREDICTION_FILE_SIZE_BYTES))
return 1
strive:
predictions = make_datarobot_deployment_unstructured_predictions(knowledge, deployment_id, mimetype, charset)
return json.masses(predictions)('reply')
besides DataRobotPredictionError as exc:
pprint(exc)
return NoneMaintenant que nous avons le script généré automatiquement pour faire nos prédictions, il est temps d’envoyer une demande de prédiction de check. Créons un JSON pour poser une query à notre modèle BERT de réponse aux questions. Nous lui donnerons un lengthy résumé pour l’info, et la query basée sur ce résumé.
test_input = {"summary": "Healthcare duties (e.g., affected person care by way of illness remedy) and biomedical analysis (e.g., scientific discovery of recent therapies) require professional information that's restricted and costly. Basis fashions current clear alternatives in these domains as a result of abundance of knowledge throughout many modalities (e.g., photographs, textual content, molecules) to coach basis fashions, in addition to the worth of improved pattern effectivity in adaptation as a consequence of the price of professional time and information. Additional, basis fashions might enable for improved interface design (§2.5: interplay) for each healthcare suppliers and sufferers to work together with AI methods, and their generative capabilities recommend potential for open-ended analysis issues like drug discovery. Concurrently, they arrive with clear dangers (e.g., exacerbating historic biases in medical datasets and trials). To responsibly unlock this potential requires partaking deeply with the sociotechnical issues of knowledge sources and privateness in addition to mannequin interpretability and explainability, alongside efficient regulation of using basis fashions for each healthcare and biomedicine.", "query": "The place can we use basis fashions?"}
datarobot_predict(test_input, deployment.id)Et voyez que notre modèle renvoie la réponse dans la réponse du modèle, comme nous l’attendions.
> each healthcare and biomedicine
Surveillez facilement les modèles d’apprentissage automatique avec DataRobot MLOps
Maintenant que notre modèle de questions-réponses est opérationnel avec succès, observons notre tableau de bord de santé du service dans DataRobot MLOps. Lorsque nous envoyons des requêtes de prédiction à notre modèle, le Santé des companies reflétera les nouvelles demandes reçues et nous permettra de garder un œil sur les métriques de notre modèle.
Plus tard, si nous voulons mettre à jour notre déploiement avec une model plus récente de l’artefact de modèle pré-entraîné ou mettre à jour notre script d’inférence personnalisé, nous utilisons à nouveau l’API ou l’interface utilisateur de l’atelier de modèle personnalisé pour apporter parfaitement les modifications nécessaires à notre déploiement.
Commencer à utiliser les grands modèles de langage
En hébergeant un modèle de langage avec DataRobot MLOps, les organisations peuvent tirer parti de la puissance et de la flexibilité des grands modèles de langage sans avoir à se soucier des détails strategies de gestion et de déploiement du modèle.
Dans cet article de weblog, nous avons montré à quel level il est facile d’héberger un grand modèle de langage en tant que modèle personnalisé DataRobot en quelques minutes seulement en exécutant un script de bout en bout. Vous pouvez trouver le bloc-notes de bout en bout dans le Référentiel de la communauté DataRobotfaites-en une copie pour la modifier selon vos besoins et mettez-vous au level avec votre propre modèle en manufacturing.
A propos de l’auteur
Ingénieur principal en apprentissage automatique, DataRobot
Aslı Sabancı Demiröz est ingénieur principal en apprentissage automatique chez DataRobot. Elle est titulaire d’un BS en génie informatique avec une double majeure en génie du contrôle de l’Université approach d’Istanbul. Travaillant au bureau du CTO, elle aime être au cœur de la R&D de DataRobot pour stimuler l’innovation. Sa ardour réside dans l’espace d’apprentissage en profondeur et elle aime particulièrement créer des intégrations puissantes entre les couches de plate-forme et d’software dans l’écosystème ML, visant à rendre le tout supérieur à la somme des events.
