Transformadores para Multi-Regresión — [PART2] – Hacia la IA

Estás leyendo la publicación: Transformadores para Multi-Regresión — [PART2] – Hacia la IA

Publicado originalmente en Hacia la IA, la empresa líder mundial en noticias y medios de IA y tecnología. Si está creando un producto o servicio relacionado con la IA, lo invitamos a considerar convertirse en patrocinador de la IA. En Hacia la IA, ayudamos a escalar las empresas emergentes de IA y tecnología. Permítanos ayudarlo a dar rienda suelta a su tecnología a las masas.

? Sintonia FINA ?

en el contexto de la competencia FB3, nuestro objetivo es modelar seis métricas de análisis utilizando ensayos argumentativos precalificados escritos por estudiantes del idioma inglés de 8.º a 12.º grado. Las habilidades que tenemos que modelar son las siguientes: cohesión, sintaxis, vocabulario, fraseología, gramáticay convenciones. Las puntuaciones oscilan entre 1,0 y 5,0 en incrementos de 0,5.

En mi última publicaciónle mostré cómo usar un transformador preentrenado para extraer incrustaciones de captura de contexto y usarlas para entrenar un regresor múltiple.

Esta vez le mostraré cómo entrenar de extremo a extremo todo el transformador, lo que también significa actualizar los parámetros del modelo preentrenado.

Además, te mostraré cómo usar la plataforma de pesos y sesgos: desde el inicio de sesión con el varita mágica API, para crear y usar artefactos de modelo y pasar a través de la pista del modelo.

Todas las fuentes de código se pueden recuperar de mi cuaderno Kaggle

Crédito: En esta parte, tomé prestado @debarshichanda arquitectura del modelo.

?Importaciones y configuración

En primer lugar, definiremos el diccionario CONFIG y las importaciones relacionadas con el transformador que usaremos en todo el proyecto:

antorcha de importación
importar torch.nn como nn
importar transformadores
de importación de transformadores (
AutoModelo, AutoConfiguración,
AutoTokenizer, registro,
AdamW, get_linear_schedule_with_warmup,
DataCollatorWithPadding,
Entrenador, EntrenamientoArgumentos
)
desde transformers.modeling_outputs import SequenceClassifierOutput

registro.set_verbosidad_error()
registro.set_verbosity_warning()

CONFIG = {
“model_name”: “microsoft/deberta-v3-base”,# “distilbert-base-sin carcasa”,
“dispositivo”: ‘cuda’ si torch.cuda.is_disponible() de lo contrario ‘cpu’,
“abandono”: aleatorio.uniforme (0.01, 0.60),
“longitud_máxima”: 512,
“train_batch_size”: 8,
“tamaño_de_lote_válido”: 16,
“épocas”: 10,
“pliegues”: 3,
“max_grad_norm”: 1000,
“peso_decaimiento”: 1e-6,
“tasa_de_aprendizaje”: 1e-5,
“loss_type”: “rmse”,
“n_acumula”: 1,
“etiqueta_cols”: [‘cohesion’, ‘syntax’, ‘vocabulary’, ‘phraseology’, ‘grammar’, ‘conventions’],

}

?Iterador de conjunto de datos personalizado:

Como se explicó en la publicación anterior, definiremos una subclase de torch.utils.data.Dataset y anularemos los métodos especiales __init__, __len__ y __getitem__ de la siguiente manera:

importar pandas como pd

tren = pd.read_csv(RUTA_AL_TREN)
prueba = pd.read_csv(RUTA_A_PRUEBA)

# definamos el generador de lotes
clase CustomIterator(torch.utils.data.Dataset):
def __init__(self, df, tokenizador, etiquetas=CONFIG[‘label_cols’]es_tren=Verdadero):
self.df = df
self.tokenizer = tokenizador
self.max_seq_length = CONFIG[“max_length”]# tokenizer.model_max_length
self.etiquetas = etiquetas
self.es_tren = es_tren

def __getitem__(self,idx):
fichas = self.tokenizer(
self.df.loc[idx, ‘full_text’],#.Listar(),
add_special_tokens=Verdadero,
relleno = ‘longitud_máxima’,
max_length=self.max_seq_length,
truncamiento=Verdadero,
return_tensores=’pt’,
return_attention_mask=Verdadero
)
resolución = {
‘input_ids’: fichas[‘input_ids’].to(CONFIG.get(‘dispositivo’)).apretar(),
‘attention_mask’: fichas[‘attention_mask’].to(CONFIG.get(‘dispositivo’)).apretar()
}

si self.is_train:
resolución[“labels”] = antorcha.tensor(
self.df.loc[idx, self.labels].Listar(),
).to(CONFIG.get(‘dispositivo’))

volver res

def __len__(uno mismo):
devolver len(self.df)

? Transformador de ajuste fino

Con este enfoque, los estados ocultos no son fijos sino entrenables: por esta razón, requiere que el encabezado de clasificación sea diferenciable Por lo general, usamos una red neuronal para el clasificador.

En esta sección, veremos cómo ajustar un transformador de codificador basado en el modelo preentrenado microsoft/deberta-v3-base, usando una API de evaluación y entrenamiento simple y con funciones completas proporcionada por HuggingFace: el Entrenador.

Definiremos un modelo personalizado que amplíe microsoft/deberta-v3-base con una cabeza de red neuronal entrenable.

El modelo personalizado estará compuesto por:

• Modelo de línea base preentrenado : cargue el microsoft/deberta-v3-base preentrenado con la función AutoModel.from_pretrained
• Capa de agrupación media: necesitamos agregar algunos cambios a la función Mean Pooling anterior (ver parte uno post): hereda de torch.nn.Module la clase de agrupación y define la función de agrupación media dentro de un método de reenvío (consulte el código a continuación)
• capa de abandono: agregue una capa de abandono para la regularización
• capa lineal: tamaño de entrada = hidden_state_dim, tamaño de salida = número de características de destino (6)

La salida de logits de la capa lineal se devuelve a través de SequenceClassifierOutput, una subclase de la clase ModelOutput, en el método directo (Todos los modelos deben tener salidas que sean instancias de subclases de ModelOutput: referencia aquí )

clase MeanPooling(nn.Módulo):
def __init__(uno mismo):
super(MeanPooling, self).__init__()
def adelante(self, last_hidden_state,tention_mask):
input_mask_expanded = atención_mask.unsqueeze(-1).expand(last_hidden_state.size()).float()
sum_embeddings = antorcha.sum(last_hidden_state * input_mask_expanded, 1)
máscara_suma = máscara_entrada_expandida.suma(1)
sum_mask = antorcha.clamp(sum_mask, min=1e-9)
mean_embeddings = sum_embeddings / sum_mask
devolver medias_incrustaciones

clase FeedBackModel (nn. Módulo):
def __init__(self, modelo_nombre):
super(FeedBackModel, auto).__init__()
self.config = AutoConfig.from_pretrained(modelo_nombre)
self.config.hidden_dropout_prob = 0
self.config.attention_probs_dropout_prob = 0
self.model = AutoModel.from_pretrained(model_name, config=self.config)
self.drop = nn.Dropout(p=0.2)
self.pooler = MeanPooling()
self.fc = nn.Linear(self.config.hidden_size, len(CONFIG[‘label_cols’]))

def adelante (auto, input_ids, atención_mask):
out = self.model(input_ids=input_ids,
máscara_atención=máscara_atención,
salida_hidden_states=Falso)
fuera = self.pooler(fuera.último_estado_oculto, máscara_de_atención)
fuera = self.drop(fuera)
salidas = self.fc(salida)
devuelve SequenceClassifierOutput(logits=salidas)

Pérdida y Métrica

Como usaremos un entrenador, necesitamos definir una nueva función de pérdida correspondiente a la métrica de evaluación objetivo (en nuestros casos, MCRMSE). Esta función de pérdida se usará para entrenar el transformador. La forma de implementar esto es definir un Entrenador de subclases y anular el método compute_loss().

De la misma manera, queremos obtener la evaluación local para cada clase de destino durante el paso de evaluación, por lo que proporcionaremos al Entrenador una función de cálculo_métricos() personalizada que permita calcular el RMSE de cada uno de los seis objetivos (De lo contrario, la evaluación sería solo he devuelto la evaluación de pérdidas: el MCRMSE).

clase RMSELoss(nn.Módulo):
“””
Código tomado del cuaderno de Y Nakama (https://www.kaggle.com/code/yasufuminakama/fb3-deberta-v3-base-baseline-train)
“””
def __init__(self, reducción=’media’, eps=1e-9):
super().__init__()
self.mse = nn.MSELoss(reducción=’ninguna’)
self.reduction = reducción
self.eps = eps

def adelante (auto, predicciones, objetivos):
pérdida = antorcha.sqrt(self.mse(predicciones, objetivos) + self.eps)
if auto.reducción == ‘ninguno’:
pérdida = pérdida
elif auto.reducción == ‘suma’:
pérdida = pérdida.sum()
elif auto.reducción == ‘media’:
pérdida = pérdida.media()
pérdida de retorno

clase CustomTrainer(Entrenador):
def compute_loss(self, modelo, entradas, return_outputs=False):
salidas = modelo (entradas[‘input_ids’]entradas[‘attention_mask’])
loss_func = RMSELoss(reducción=’media’)
pérdida = pérdida_func(salidas.logits.float(), entradas[‘labels’].flotar())
retorno (pérdida, salidas) si retorno_salidas si no pérdida

def computar_métricas(eval_pred):
predicciones, etiquetas = eval_pred
colwise_rmse = np.sqrt(np.mean((etiquetas – predicciones) ** 2, eje=0))
resolución = {
f”{analytic.superior()}_RMSE”: colwise_rmse[i]
para i, analítico en enumerar (CONFIG[“label_cols”])
}
resolución[“MCRMSE”] = np.media(colwise_rmse)
volver res

?Pesos y sesgos?

A pesar de que HuggingFace Transformers proporciona una amplia gama de instalaciones de puntos de control de capacitación. W&B proporciona potentes herramientas de control de versiones de modelos y seguimiento de experimentos con paneles amigables e interactivos. Cada proyecto de experimento se divide por sí solo.

Verificar este excelente cuaderno que describe en detalle cómo usar W&B en kaggle:

? Panel (seguimiento de experimentos): Registre y visualice experimentos en tiempo real = Mantenga los datos y los resultados en un lugar conveniente. Considere esto como un depósito de experimentos.

? Artefactos (conjunto de datos + control de versiones del modelo): almacenamiento y versión de conjuntos de datos, modelos y resultados = Sepa exactamente en qué datos se está entrenando un modelo.

Para conectarnos a Pesos y sesgos, necesitamos Acceder a su clave API desde https://wandb.ai/autorizar.
Hay dos formas de iniciar sesión con un kernel de Kaggle:

• Use los secretos de Kaggle para almacenar su clave API: y use el fragmento de código a continuación para iniciar sesión.

1. Haga clic en los menús Complementos en el Editor de Notebook y luego en Secretos:

2. Guarde la clave api como un par clave-valor que se adjuntará al Notebook actual:

3. Copie y pegue el fragmento de código para acceder a la clave API y luego use wandb.login() para conectarse a W&B:

desde kaggle_secrets importar UserSecretsClient
importar varita

user_secrets = UserSecretsClient()
clave_api = secretos_de_usuario.get_secret(“wandb_api”)
wandb.login(clave=clave_api)

Argumentos de ?Wandb

Para cada iteración de CV ‘i’ crearemos una nueva ejecución llamada FB3-fold-i con ‘i’ = número de iteración, dentro de un solo proyecto que llamaremos Feedback3-deberta.

Algunos otros parámetros:

• grupo: el parámetro de grupo se usa especialmente para organizar ejecuciones individuales en un experimento más grande, aquí hay algunos ejemplos de casos de uso
• etiquetas: agregaremos el nombre del modelo y las etiquetas métricas. como se explica en el documento de W&B, las etiquetas son útiles para organizar tiradas juntas o aplicar etiquetas temporales como “línea de base” o “producción”. Es fácil agregar y eliminar etiquetas en la interfaz de usuario o filtrar para ejecutar solo con una etiqueta específica.
• job_type: por lo general es “entrenamiento” o “eval”. Posteriormente, permitiría filtrar y agrupar corridas similares. Estableceremos job_type en “tren”
• anónimo: este parámetro permite controlar el registro anónimo. lo configuraremos para “debe” que enviaría la ejecución a una cuenta anónima en lugar de a una cuenta de usuario registrada. Para las otras opciones, puede consultar la documentación

Para cada iteración de CV, podemos instanciar una ejecución de wandb de la siguiente manera:

ejecutar = wandb.init(proyecto=”FB3-deberta-v3″,
config=CONFIG,
job_type=’entrenar’,
grupo=”FB3-LINEA-BASE-MODELO”,
etiquetas=[CONFIG[‘model_name’]CONFIGURAR[‘loss_type’]”10-épocas”],
nombre=f’FB3-fold-{fold}’,
anónimo = ‘debe’)

Ahora definamos los argumentos de entrenamiento que utilizará Huggingface Trainer

?Argumentos de entrenamiento

Antes de crear una instancia de nuestro Entrenador personalizado, crearemos un TrainingArguments para definir la configuración de entrenamiento.
Estableceremos los siguientes parámetros:

• output_dir : el directorio de salida donde se escribirán las predicciones del modelo y los puntos de control: cada iteración de CV tendría su propio directorio con un nombre igual al número de iteraciones con el prefijo “producción-“
• evaluación_estrategia : establecido en “época” lo que significa que la Evaluación se realiza al final de cada época.
• per_device_train_batch_size: el tamaño del lote para el entrenamiento. Lo pondremos en 8
• per_device_eval_batch_size: el tamaño del lote para la evaluación. Lo pondremos en 16 (para acelerar la ejecución del tiempo)
• num_train_epochs: número de épocas de entrenamiento. Como recordatorio, durante una época, el modelo ha visto cada muestra del conjunto de datos de entrenamiento.
• group_by_length: siempre que usemos el relleno dinámico, estableceremos este parámetro en True para agrupar muestras de aproximadamente la misma longitud en el conjunto de datos de entrenamiento (para minimizar el relleno aplicado y ser más eficiente)
• max_grad_norm: norma máxima de gradiente (para recorte de gradiente).
• learning_rate: La tasa de aprendizaje inicial para AdánW optimizador Como recordatorio, el optimizador AdamW
• weight_decay: El decaimiento de peso para aplicar al optimizador AdamW: en nuestro caso, aplicaremos el decaimiento de peso a todas las capas excepto sesgos y capas de normalización

Nota :
El decaimiento de peso es una técnica de regularización que agrega una pequeña penalización a la función de pérdida (generalmente la norma L2 de los pesos).
pérdida = pérdida + parámetro_deterioro_de_peso * norma_L2_de_los_pesos

Algunas implementaciones aplican la disminución del peso solo a los pesos y no al sesgo. Por otro lado, PyTorch aplica el decaimiento de peso tanto a los pesos como al sesgo.

¿Por qué decaimiento de peso?

1. Para evitar el sobreajuste.
2. Para evitar la explosión del gradiente: debido a la norma L2 adicional, cada iteración de su red intentará optimizar los pesos del modelo además de la pérdida. Esto ayudará a mantener los pesos lo más pequeños posible, evitando que los pesos crezcan fuera de control y, por lo tanto, evitando la explosión del gradiente.

• gradiente_accumulación_pasos: número de pasos en los que se deben acumular los gradientes antes de realizar un paso hacia atrás: cuando se utiliza la acumulación de gradiente, el cálculo del gradiente se realiza en pasos más pequeños en lugar de todos a la vez para un lote; 1 (significa que no hay acumulación de gradiente))

Nota:
En esto Discusión de desbordamiento de pila, se ha explicado cómo usar el parámetro set gradient_accumulation_steps para evitar errores OOM: establezca el argumento gradient_accumulation_steps en un número que quepa en la memoria y modifique per_device_train_batch_size a original_batch_size/gradient_accumulation_steps: para que los gradientes se acumulen a través de gradient_accumulation_steps, y se realizaría un paso hacia atrás a través de muestras de gradient_accumulation_steps*original_batch_size/gradient_accumulation_steps=original_batch_size. El número total de pasos de entrenamiento sería:

• load_best_model_at_end: lo estableceremos en True para cargar el mejor modelo encontrado durante el entrenamiento al final del entrenamiento: en este caso, save_strategy debe ser el mismo que Evaluation_strategy: época en nuestro caso
• metric_for_best_model: estableceremos la métrica de la competencia MCRMSE o eval_MCRMSE (con prefijo eval_)
• great_is_better: configúrelo en False, porque queremos obtener el modelo con un MCRMSE más bajo
• save_total_limit: lo estableceremos en 1 para mantener siempre un punto de control a la vez (se eliminarán los puntos de control más antiguos en output_dir).
• report_to: como estamos conectados a W&B, estableceremos los registros de report_to en “wandb”
• label_name: establece la lista de parámetros label_name en [“labels”], que corresponde al campo previamente definido producido por nuestro cargador de datos personalizado correspondiente a las clases de destino

training_args = Argumentos de Entrenamiento(
salida_dir=f”salidas-{fold}/”,
evaluación_estrategia=”época”,
per_device_train_batch_size=CONFIGURAR[‘train_batch_size’],
per_device_eval_batch_size=CONFIG[‘valid_batch_size’],
num_train_epochs=CONFIG[‘epochs’],
tasa_de_aprendizaje=CONFIG[‘learning_rate’],
weight_decay=CONFIGURACIÓN[‘weight_decay’],
gradiente_accumulación_pasos=CONFIGURACIÓN[‘n_accumulate’],
semilla = SEMILLA,
group_by_length=Verdadero,
max_grad_norm=CONFIGURAR[‘max_grad_norm’],
metric_for_best_model=’eval_MCRMSE’,
load_best_model_at_end=Verdadero,
great_is_better=Falso,
save_strategy=”época”,
guardar_límite_total=1,
report_to=”wandb”,
etiqueta_nombres=[“labels”]
)

Además, definiremos algunos otros parámetros para el Entrenador:

• recopilador de datos: necesitamos definir cómo crear un solo lote de la lista de entradas de datos devueltas por el cargador de datos
  Usaremos DataCollatorWithPadding que rellenará dinámicamente las entradas recibidas.
• optimizador: usaremos AdamW con decaimiento en todas las capas excepto en las capas de polarización y normalización
• planificador: usaremos get_linear_schedule_with_warmup para crear un programa con un período de calentamiento durante el cual la tasa de aprendizaje aumenta linealmente desde 0 hasta el lr inicial (establecido en el optimizador) y luego disminuye linealmente desde el lr inicial establecido en el optimizador hasta 0.
  El Programador nos permite llevar el control de la tasa de aprendizaje si, por ejemplo, queremos asegurarnos de que cada actualización de la tasa de aprendizaje no supere un valor lambda (verifique esto Discusión de desbordamiento de pila sobre la utilidad del programador del optimizador)

Para iniciar el entrenamiento de validación cruzada, primero, tenemos que crear las columnas de pliegue de CV como se explica en el PARTE1 publicación:

# establecer semilla para producir pliegues similares
cv = MultilabelStratifiedKFold(n_splits=CONFIG.get(“folds”, 3), shuffle=True, random_state=SEED)

tren = tren.reset_index(soltar=Verdadero)
for fold, ( _, val_idx) en enumerate(cv.split(X=tren, y=tren[CONFIG[‘label_cols’]])):
tren.loc[val_idx , “fold”] = int(doblar)

tren[“fold”] = tren[“fold”].astype(int)

El flujo de trabajo de capacitación de CV se puede implementar de la siguiente manera:

# Colector de datos para relleno dinámico
collate_fn = DataCollatorWithPadding(tokenizador=tokenizador)
# predicciones de inicio por pliegue
predicciones = {}
para plegar en rango (0, CONFIG[‘folds’]):
imprimir(f” —- Doblar: {doblar} —-“)
ejecutar = wandb.init(proyecto=”FB3-deberta-v3″,
config=CONFIG,
job_type=’entrenar’,
grupo=”FB3-LINEA-BASE-MODELO”,
etiquetas=[CONFIG[‘model_name’]CONFIGURAR[‘loss_type’]”10-épocas”],
nombre=f’FB3-fold-{fold}’,
anónimo = ‘debe’)
# el índice de reinicio es MUY IMPORTANTE para el iterador del conjunto de datos
df_tren = tren[train.fold != fold].reset_index(soltar=Verdadero)
df_valid = tren[train.fold == fold].reset_index(soltar=Verdadero)
# crear iteradores
train_dataset = CustomIterator(df_train, tokenizador)
valid_dataset = CustomIterator(df_valid, tokenizer)
# modelo inicial
modelo = FeedBackModel(CONFIG[‘model_name’])
modelo.a(CONFIG[‘device’])

# CONFIGURAR EL OPTIMIZADOR Y EL PROGRAMADOR
# sin decaimiento para las capas de polarización y normalización
param_optimizer = list(model.named_parameters())
no_decay = [“bias”, “LayerNorm.weight”]
parámetros_optimizadores = [
{
“params”: [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],
“weight_decay”: CONFIGURACIÓN[‘weight_decay’],
},
{
“parámetros”: [p for n, p in param_optimizer if any(nd in n for nd in no_decay)],
“peso_deterioro”: 0.0,
},
]
optimizador = AdamW(optimizer_parameters, lr=CONFIG[‘learning_rate’])
num_training_steps = (len(train_dataset) * CONFIG[‘epochs’]) // (CONFIGURAR[‘train_batch_size’] * CONFIGURAR[‘n_accumulate’])
programador = get_linear_schedule_with_warmup(
optimizador,
num_warmup_steps=0.1*num_training_steps,
num_training_steps=num_training_steps
)
# CREAR EL ENTRENADOR
entrenador = EntrenadorPersonalizado(
modelo = modelo,
argumentos=argumentos_de_entrenamiento,
train_dataset=tren_conjunto de datos,
eval_dataset=conjunto_de_datos_válido,
data_collator=cotejar_fn,
optimizadores=(optimizador, planificador),
cómputo_métricas=cómputo_métricas
)
# LANZA EL ENTRENADOR
entrenador.entrenar()

Puede acceder a mi panel de W&B público que creé para este proyecto: https://wandb.ai/athena75/FB3-deberta-v3?workspace=user-athena75

?Crear artefactos W&B

Para uso posterior, W&B es muy conveniente para crear artefactos de modelo una vez que el modelo está ajustado. Podemos usarlos más tarde y crear nuevas versiones de nuestros modelos.

Para crear un artefacto modelo, todo lo que tiene que hacer es:

1. Cree un objeto wandb.Artifact con un nombre claro y consistente, y debe especificar el parámetro de tipo, puede ser un conjunto de datos o un modelo, en nuestro caso modelo
2. Agregue el directorio local al artefacto: de hecho, una vez que crea una instancia del modelo y comienza a ajustarlo, crea un punto de control local que contiene el contenedor del modelo, así como el estado y la configuración del modelo. Tienes que añadirlo al artefacto.
3. Una vez que el artefacto tenga todos los archivos deseados, puede llamar a wandb.log_artifact() para registrarlo.

Aquí hay un ejemplo de código de recorte de la creación de un artefacto para cada modelo de CV:

para plegar en rango (0, CONFIG[‘folds’]):
ejecutar = wandb.init(proyecto=”FB3-deberta-v3″,
config=CONFIG,
job_type=’entrenar’,
grupo=”FB3-LINEA-BASE-MODELO”,
etiquetas=[CONFIG[‘model_name’]CONFIGURAR[‘loss_type’]”10-épocas”],
nombre=f’FB3-fold-{fold}’,
anónimo = ‘debe’)

entrenador = EntrenadorPersonalizado(
…..
)
##### TREN / AJUSTE FINO ####
# crear artefacto modelo
model_artifact = wandb.Artifact(f’FB3-fold-{fold}’, type=”model”,
description=f”MultilabelStratified – fold–{fold}”)
# guardar localmente el modelo – crearía un directorio local
trainer.save_model(f’fold-{fold}’)
# agregar el directorio local al artefacto
model_artifact.add_dir(f’fold-{fold}’)
# artefacto de registro
# guardaría la versión del artefacto y declararía el artefacto como una salida de la ejecución
ejecutar.log_artifact(modelo_artefacto)

ejecutar.terminar()

✨Utilice artefactos de W&B para la inferencia✨:

Una vez realizado el entrenamiento, podemos utilizar los artefactos almacenados en el servidor de Pesos y sesgos, en nuestro caso, para generar predicciones de modelo y generar una predicción de salida agregada.

PD: puede extraer el código de uso directamente desde la interfaz de W&B https://wandb.ai/athena75/Feedback3-deberta/artifacts/model/FB3-fold-0/93c08783e5b7c696451a/usage

1. inicie sesión en su cuenta de wandb e instancia una ejecución predeterminada con wandb.init()
2. Indique al método use_artifact() la ruta a su artefacto así como el tipo (el modelo en nuestro caso) para recuperar el artefacto
3. Descargue el directorio de artefactos localmente usando el método download()
4. Cargue el modelo local y utilícelo para hacer predicciones

Ejemplo de implementación:

predicciones = torch.zeros((len(prueba), len(CONFIG[‘label_cols’]))

para plegar en rango (CONFIG[“folds”]):
imprimir(f”—- PLEGAR {doblar} ——-“)
# instanciar la ejecución predeterminada
ejecutar = wandb.init()
# Indicar el artefacto que queremos usar con el método use_artifact.
artefacto = ejecutar.use_artifact(f’athena75/FB3-deberta-10/FB3-fold-{fold}:v0′, type=’model’)
# descargar localmente el modelo
artefacto_dir = artefacto.descargar()
# carga el modelo local
# es un antorcha moeal: cargado de la siguiente manera
# https://pytorch.org/tutorials/beginner/saving_loading_models.html
modelo = FeedBackModel(CONFIG[‘model_name’])
model.load_state_dict(torch.load(f’artifacts/FB3-fold-{fold}:v0/pytorch_model.bin’))
# generar incrustaciones de prueba
test_dataset = CustomIterator(prueba, tokenizador, is_train=False)
test_dataloader = antorcha.utils.data.DataLoader(
conjunto_de_datos_de_prueba,
tamaño_lote=CONFIG[“train_batch_size”],
barajar = falso
)
input_ids, máscara_atención = tupla(siguiente(iter(test_dataloader)).valores())
input_ids = input_ids.to(‘cpu’)
máscara_atención = máscara_atención.to(‘cpu’)
# generar predicciones
fold_preds = modelo (input_ids, atención_mask)
predicciones = fold_preds.logits.add(predicciones)
# eliminar el directorio local para ahorrar espacio
shutil.rmtree(‘artefactos’)

?Créditos:

Este trabajo es una génesis singular de estos excelentes recursos, no dude en votar los recursos de Kaggle:

Conclusión:

¡Muchas gracias por leer mis publicaciones! ?, les comparto todo mi trabajo: este Cuaderno Kaggleasí como mi público Tablero de W&B.

Espero que haya sido claro, y no dude en hacerme preguntas.

?Mi dirección de correo es: [email protected]?

Para un post posterior, pretendo abordar el tema de cómo implementar un transformador en producción. O cómo construir un Tubería MLOps para transformadores NLP, aun no me decido…

---

Transformadores para Multi-Regresión — [PART2] se publicó originalmente en Hacia la IA en Medium, donde las personas continúan la conversación destacando y respondiendo a esta historia.

Publicado a través de Hacia la IA