Los modelos de lenguaje extenso, también conocidos como modelos básicos, han ganado una tracción significativa en el campo de la aprendizaje automático. Estas modelos están pre-entrenados en grandes conjuntos de datos, lo que les permite desempeñarse bien en una variedad de tareas sin requerir tantos datos de entrenamiento. Aprenda cómo puede implementar fácilmente un modelo de base entrenado previamente usando el MLOps de DataRobot capacidades, luego ponga el modelo en producción. Al aprovechar el poder de un modelo previamente entrenado, puede ahorrar tiempo y recursos mientras logra un alto rendimiento en sus aplicaciones de aprendizaje automático.
¿Qué son los modelos de lenguaje grande?
La creación de modelos básicos es uno de los desarrollos clave en el campo de los modelos de lenguaje grande que está creando mucho entusiasmo e interés entre científicos de datos e ingenieros de aprendizaje automático. Estos modelos están entrenados en cantidades masivas de datos de texto utilizando algoritmos de aprendizaje profundo. Tienen la capacidad de generar un lenguaje related al humano que es coherente y relevante en un contexto determinado y de procesar y comprender el lenguaje pure a un nivel que antes se creía imposible. Como resultado, tienen el potencial de revolucionar la forma en que interactuamos con las máquinas y resolver una amplia gama de problemas de aprendizaje automático.
Estos desarrollos han permitido a los investigadores crear modelos que pueden realizar una amplia gama de procesamiento pure del lenguaje tareas, como traducción automática, resumen, respuesta a preguntas e incluso generación de diálogos. También se pueden usar para tareas creativas, como generar texto realista, que puede ser útil para una variedad de aplicaciones, como generar descripciones de productos o crear artículos de noticias.
En common, los desarrollos recientes en modelos de lenguaje grande son muy emocionantes y tienen el potencial de mejorar en gran medida nuestra capacidad para resolver problemas de aprendizaje automático e interactuar con máquinas de una manera más pure e intuitiva.
Comience con los modelos de lenguaje usando Hugging Face
Como muchos profesionales del aprendizaje automático ya saben, una manera fácil de comenzar con los modelos de lenguaje es usar Hugging Face. Hugging Face mannequin hub es una plataforma que ofrece una colección de modelos previamente entrenados que se pueden descargar y usar fácilmente para una amplia gama de tareas de procesamiento de lenguaje pure.
Para comenzar con un modelo de idioma del centro de modelos Hugging Face, simplemente necesita instalar la biblioteca Hugging Face en su computadora portátil native o Cuadernos DataRobot si eso es lo que usas. Si ya ejecuta sus experimentos en la GUI de DataRobot, incluso podría agregarlo como un tarea personalizada.
Una vez instalado, puede elegir un modelo que se adapte a sus necesidades. Luego puede usar el modelo para realizar tareas como la generación, clasificación y traducción de texto. Los modelos son fáciles de usar y se pueden ajustar a sus necesidades específicas, lo que los convierte en una poderosa herramienta para resolver una variedad de problemas de procesamiento del lenguaje pure.
Si no desea configurar un entorno de tiempo de ejecución native, puede comenzar con una computadora portátil Google Colab en un tiempo de ejecución de CPU/GPU/TPU, descargar su modelo y obtener las predicciones del modelo en solo unas pocas líneas.
Como ejemplo, comenzar con un modelo BERT para responder preguntas (bert-large-uncased-whole-word-masking-finetuned-squad) es tan fácil como ejecutar estas líneas:
!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)Implementación de modelos de lenguaje en producción
Después de probar algunos modelos, posiblemente ajustarlos aún más para sus casos de uso específicos y prepararlos para la producción, necesitará un entorno de servicio para alojar sus artefactos. Además de solo un entorno para servir al modelo, deberá monitorear su rendimiento, salud, datos y desviación de predicción, y una manera fácil de volver a entrenarlo sin perturbar sus flujos de trabajo de producción y sus aplicaciones posteriores que consumen la salida de su modelo.
Aquí es donde el MLOps de DataRobot entra en juego. Los servicios de DataRobot MLOps brindan una plataforma para hospedar e implementar paquetes de modelos personalizados en varios marcos de ML, como PyTorch, Tensorflow, ONNX y sk-learn, lo que permite a las organizaciones integrar fácilmente sus modelos previamente entrenados en sus aplicaciones existentes y consumirlos para su negocio. necesidades.
Para alojar un modelo de lenguaje previamente entrenado en los servicios de DataRobot MLOps, simplemente necesita cargar el modelo en la plataforma, crear su entorno de tiempo de ejecución con sus paquetes de dependencia personalizados e implementarlo en los servidores de DataRobot. Su implementación estará lista en unos minutos y luego podrá enviar sus solicitudes de predicción a su punto ultimate de implementación y disfrutar de su modelo en producción.
Si bien puede realizar todas estas operaciones desde la interfaz de usuario de DataRobot, aquí le mostraremos cómo implementar el flujo de trabajo de extremo a extremo mediante la API de Datarobot en un entorno de pocket book. ¡Entonces empecemos!
Puede seguir este tutorial creando un nuevo cuaderno de Google Colab o copiando nuestro cuaderno de nuestro Repositorio de la comunidad DataRobot y ejecutando el cuaderno copiado en Google Colab.
Instalar dependencias
!pip set up transformers==4.25.1 datarobot==3.0.2
from transformers import AutoTokenizer, TFBertForQuestionAnswering
import numpy as npDescargue el modelo BERT de HuggingFace en el entorno del portátil
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)
Implementar en DataRobot
Cree el script de inferencia (pegamento), es decir. el archivo customized.py.
Este script de inferencia (archivo customized.py) actúa como el enlace entre los artefactos de su modelo y la ejecución del modelo personalizado en DataRobot. Si es la primera vez que crea un modelo personalizado en DataRobot MLOps, nuestro repositorio público será un excelente punto de partida, con muchos más ejemplos de plantillas de modelos en diferentes marcos de ML y para diferentes tipos de modelos, como clasificación binaria o multiclase, regresión, detección de anomalías o modelos no estructurados como el que construiremos en nuestro ejemplo .
%%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 ready
is_batch = kwargs("mimetype") == "textual content/csv"
if is_batch:
input_pd = pd.read_csv(io.StringIO(knowledge), sep="|")
input_pairs = listing(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.hundreds(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_returnCrear el archivo de requisitos
%%writefile $BASE_PATH/necessities.txt
transformersCargue artefactos de modelos y secuencias de comandos de inferencia en DataRobot
import datarobot as dr
def deploy_to_datarobot(folder_path, env_name, model_name, descr):
API_TOKEN = "YOUR_API_TOKEN" #Please seek advice from https://docs.datarobot.com/en/docs/platform/account-mgmt/acct-settings/api-key-mgmt.html to get your token
dr.Shopper(token=API_TOKEN, endpoint="https://app.datarobot.com/api/v2/")
onnx_execution_env = dr.ExecutionEnvironment.listing(search_for=env_name)(0)
custom_model = dr.CustomInferenceModel.create(
title=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.listing(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"Surroundings construct accomplished with {build_info.build_status}.")
print("Creating mannequin deployment...")
default_prediction_server = dr.PredictionServer.listing()(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 deploymentCrear la implementación del modelo
deployment = deploy_to_datarobot(BASE_PATH,
"Keras",
"blog-bert-tf-questionAnswering",
"Pretrained BERT mannequin, fine-tuned on SQUAD for query answering")Prueba con solicitudes de predicción
El siguiente script está diseñado para hacer predicciones contra su implementación, y puede obtener el mismo script abriendo su cuenta de DataRobot, yendo a la Despliegues pestaña, abriendo la implementación que acaba de crear, yendo a la predicciones pestaña, y luego abriendo la Código de secuencias de comandos de la API de predicción -> Único sección.
Se verá como el ejemplo a continuación, donde verá su propia API_KEY y DATAROBOT_KEY completada.
"""
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 suggest 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 will probably be decoded with supplied or default(UTF-8) charset
and handed into the 'score_unstructured' hook applied 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-Kind': '{};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 simply too giant: {} bytes. '
'Max allowed dimension 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 simply too giant: {} bytes. '
'Max allowed dimension 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.hundreds(predictions)('reply')
besides DataRobotPredictionError as exc:
pprint(exc)
return NoneAhora que tenemos el script generado automáticamente para hacer nuestras predicciones, es hora de enviar una solicitud de predicción de prueba. Vamos a crear un JSON para hacer una pregunta a nuestro modelo BERT de respuesta a preguntas. Le daremos un resumen largo para la información y la pregunta basada en este resumen.
test_input = {"summary": "Healthcare duties (e.g., affected person care through illness therapy) and biomedical analysis (e.g., scientific discovery of recent therapies) require knowledgeable 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 on account of the price of knowledgeable time and information. Additional, basis fashions could enable for improved interface design (§2.5: interplay) for each healthcare suppliers and sufferers to work together with AI programs, and their generative capabilities counsel 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 the usage of basis fashions for each healthcare and biomedicine.", "query": "The place can we use basis fashions?"}
datarobot_predict(test_input, deployment.id)Y vea que nuestro modelo devuelve la respuesta en la respuesta del modelo, como esperábamos.
> each healthcare and biomedicine
Supervise fácilmente los modelos de aprendizaje automático con DataRobot MLOps
Ahora que tenemos nuestro modelo de preguntas y respuestas en funcionamiento correctamente, observemos nuestro panel de estado del servicio en MLOps de DataRobot. A medida que enviamos solicitudes de predicción a nuestro modelo, el Estado del servicio La pestaña reflejará las solicitudes recién recibidas y nos permitirá vigilar las métricas de nuestro modelo.
Más tarde, si queremos actualizar nuestra implementación con una versión más nueva del artefacto del modelo preentrenado o actualizar nuestro script de inferencia personalizado, usamos la API o la interfaz de usuario del taller de modelos personalizados nuevamente para realizar los cambios necesarios en nuestra implementación sin problemas.
Comience a usar modelos de lenguaje grandes
Al alojar un modelo de lenguaje con DataRobot MLOps, las organizaciones pueden aprovechar el poder y la flexibilidad de los grandes modelos de lenguaje sin tener que preocuparse por los detalles técnicos de administración e implementación del modelo.
En esta publicación de weblog, mostramos lo fácil que es alojar un modelo de lenguaje grande como un modelo personalizado de DataRobot en solo unos minutos mediante la ejecución de un script de extremo a extremo. Puede encontrar el cuaderno completo en el Repositorio de la comunidad DataRobothaga una copia para editarlo según sus necesidades y póngase al día con su propio modelo en producción.
Sobre el Autor
Ingeniero sénior de aprendizaje automático, DataRobot
Aslı Sabancı Demiröz es ingeniera sénior de aprendizaje automático en DataRobot. Tiene una licenciatura en Ingeniería Informática con una doble especialización en Ingeniería de Management de la Universidad Técnica de Estambul. Al trabajar en la oficina del CTO, disfruta estar en el corazón de la I+D de DataRobot para impulsar la innovación. Su pasión radica en el espacio de aprendizaje profundo y disfruta específicamente creando integraciones poderosas entre la plataforma y las capas de aplicación en el ecosistema ML, con el objetivo de hacer que el todo sea mayor que la suma de las partes.
