Autor | huggingface compilado | fuente VK | Github
idea
Transformers está tratando de uso en investigación / biblioteca de extensión Modelo grande / transformadores para los investigadores de la PNL.
El diseño de la biblioteca tiene dos objetivos muy claros:
- Lo más sencillo y rápido de usar:
- Tratamos de limitar el número de clases orientadas a objetos para aprender lo abstracto, de hecho, casi no es una abstracción, cada modelo sólo tendrá que utilizar tres categorías: estándar de configuración, modelo y tokenizer,
- Todas estas clases están disponibles a través del público
from_pretrained()una manera simple y uniforme para inicializar desde el instantiate formación previa una instancia del método, el método será responsable de la descarga de la biblioteca, el almacenamiento en caché y la precarga clases relacionadas proporcionar una formación de modelo o guardar sus propios modelos. - Por lo tanto, esta biblioteca en lugar de construir neuronal caja de herramientas módulo de red. Si desea ampliar / construir esta biblioteca, sólo tiene que utilizar el módulo Python / PyTorch regular, y hereda de esta biblioteca clase base a modelos de reutilización tales como la carga / funciones de ahorro.
- Que ofrece el modelo más avanzado rendimiento y el modelo original tanto como sea posible:
- Los resultados que proporcionan al menos un ejemplo para cada arquitectura, que reproduce el ejemplo mencionado anteriormente de la arquitectura oficial proporcionada por el autor
- Código suele ser lo más cercano al código original, lo que significa que una parte del código puede no ser tan PyTorch pytorch de, porque este es el resultado del código TensorFlow conversión.
Varios otros objetivos:
- Expuesto modelo interno manera más coherente posible:
- Utilizamos una API para acceder a todo el peso y la atención oculta,
- Tokenizer modelo básico de la API y está normalizado para facilitar la conmutación entre los modelos.
- En combinación con una selección subjetiva de una herramienta prometedora para el ajuste fino / investigación de estos modelos:
- Sencillo / método consistente en añadir una nueva bandera a la entrada vocabulario para e incluidos en el ajuste fino,
- La máscara de forma más sencilla y recortar la cabeza del transformador.
El concepto principal
La biblioteca está construida sobre tres tipos de clases para cada modelo:
- clase del modelo se ofrece actualmente en ocho modelos en el modelo PyTorch arquitectura de la biblioteca (torch.nn.Modules), por ejemplo BertModel
- configuración de tipo, que almacena todos los parámetros necesarios para construir el modelo, por ejemplo BertConfig. No siempre tiene su propia instancia de estas configuraciones, especialmente si está utilizando un pre-formados sin ninguna modificación del modelo, el modelo creará automáticamente responsable de instanciar configuración (que es parte del modelo)
- tokenizer clase, almacena cada modelo de vocabulario, y el vocabulario para ser entregados al modelo incrustado en la lista de índice se proporciona un método para la codificación / decodificación de cadena, por ejemplo BertTokenizer
Todas estas clases se pueden crear instancias de un modelo de pre-entrenamiento y dos métodos almacenados localmente:
from_pretraining()A partir de una formación previa le permite crear una instancia de una versión del modelo / configuración / tokenizer, esta formación previa al lanzamiento puede ser proporcionado por la propia biblioteca (en la actualidad 27 modelos enumeran aquí), también pueden ser almacenados localmente por el usuario (o servidor),save_pretraining()Se le permite guardar modelo local / Configuración / tokenizer, por lo que se puede utilizarfrom_pretraining()para volver a cargarla.
Vamos a completar este viaje de inicio rápido a través de algún ejemplo sencillo de inicio rápido, para ver cómo instanciar y utilizar estas clases. El resto del documento se divide en dos partes:
- La clase principal presenta las tres categorías principales (configuración, modelo, Tokenizer) de funciones / métodos / propiedades públicas, así como alguna clase de optimización como herramientas de formación proporcionada,
- hace referencia el paquete secciones describen en detalle todas las variantes de cada clase para cada uno de los modelos de arquitectura, sobre todo cuando los llaman la entrada y la salida deseada.
Inicio rápido:
He aquí dos ejemplos muestran cierta clase y modelo de pre-formación Bert y GPT2.
Para un ejemplo de cada tipo de modelo, consulte la referencia API completa.
ejemplo BERT
Primero vamos a utilizar BertTokenizerpara preparar una entrada con token de una cadena de texto (marca BERT que debe introducirse en la lista de índice incrustado)
import torch
from transformers import BertTokenizer, BertModel, BertForMaskedLM
# 可选：如果您想了解发生的信息，请按以下步骤logger
import logging
logging.basicConfig(level=logging.INFO)
# 加载预训练的模型标记器（词汇表）
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
# 标记输入
text = "[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]"
tokenized_text = tokenizer.tokenize(text)
# 用“BertForMaskedLM”掩盖我们试图预测的标记`
masked_index = 8
tokenized_text[masked_index] = '[MASK]'
assert tokenized_text == ['[CLS]', 'who', 'was', 'jim', 'henson', '?', '[SEP]', 'jim', '[MASK]', 'was', 'a', 'puppet', '##eer', '[SEP]']
# 将标记转换为词汇索引
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)
# 定义与第一句和第二句相关的句子A和B索引（见论文）
segments_ids = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]
# 将输入转换为PyTorch张量
tokens_tensor = torch.tensor([indexed_tokens])
segments_tensors = torch.tensor([segments_ids])Vamos a ver cómo utilizar BertModella entrada se codifica en un estado oculto:
# 加载预训练模型（权重）
model = BertModel.from_pretrained('bert-base-uncased')
# 将模型设置为评估模式
# 在评估期间有可再现的结果这是很重要的！
model.eval()
# 如果你有GPU，把所有东西都放在cuda上
tokens_tensor = tokens_tensor.to('cuda')
segments_tensors = segments_tensors.to('cuda')
model.to('cuda')
#预测每个层的隐藏状态特征
with torch.no_grad():
# 有关输入的详细信息，请参见models文档字符串
outputs = model(tokens_tensor, token_type_ids=segments_tensors)
# Transformer模型总是输出元组。
# 有关所有输出的详细信息，请参见模型文档字符串。在我们的例子中，第一个元素是Bert模型最后一层的隐藏状态
encoded_layers = outputs[0]
# 我们已将输入序列编码为形状（批量大小、序列长度、模型隐藏维度）的FloatTensor
assert tuple(encoded_layers.shape) == (1, len(indexed_tokens), model.config.hidden_size)Y cómo utilizar BertForMaskedLMpredictivos escudo Etiquetas:
# 加载预训练模型（权重）
model = BertForMaskedLM.from_pretrained('bert-base-uncased')
model.eval()
# 如果你有GPU，把所有东西都放在cuda上
tokens_tensor = tokens_tensor.to('cuda')
segments_tensors = segments_tensors.to('cuda')
model.to('cuda')
# 预测所有标记
with torch.no_grad():
outputs = model(tokens_tensor, token_type_ids=segments_tensors)
predictions = outputs[0]
# 确认我们能预测“henson”
predicted_index = torch.argmax(predictions[0, masked_index]).item()
predicted_token = tokenizer.convert_ids_to_tokens([predicted_index])[0]
assert predicted_token == 'henson'OpenAI GPT-2
Aquí está un ejemplo de un inicio rápido, usando GPT2Tokenizer y GPT2LMHeadModel clases y OpenAI pre-entrenamiento modelo para predecir el siguiente marcador en el texto del mensaje.
En primer lugar, vamos a usarGPT2Tokenizer
import torch
from transformers import GPT2Tokenizer, GPT2LMHeadModel
# 可选：如果您想了解发生的信息，请按以下步骤logger
import logging
logging.basicConfig(level=logging.INFO)
# 加载预训练模型（权重）
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
# 编码输入
text = "Who was Jim Henson ? Jim Henson was a"
indexed_tokens = tokenizer.encode(text)
# 转换为PyTorch tensor
tokens_tensor = torch.tensor([indexed_tokens])Vamos a ver cómo GPT2LMHeadModella próxima generación de una ficha siguió nuestro texto:
# 加载预训练模型（权重）
model = GPT2LMHeadModel.from_pretrained('gpt2')
# 将模型设置为评估模式
# 在评估期间有可再现的结果这是很重要的！
model.eval()
# 如果你有GPU，把所有东西都放在cuda上
tokens_tensor = tokens_tensor.to('cuda')
model.to('cuda')
# 预测所有标记
with torch.no_grad():
outputs = model(tokens_tensor)
predictions = outputs[0]
# 得到预测的下一个子词（在我们的例子中，是“man”这个词）
predicted_index = torch.argmax(predictions[0, -1, :]).item()
predicted_text = tokenizer.decode(indexed_tokens + [predicted_index])
assert predicted_text == 'Who was Jim Henson? Jim Henson was a man'Ejemplos de cada modelo para cada clase de modelo de arquitectura (Bert, GPT, GPT-2, Transformador XL, XLNet y XLM) se pueden encontrar en el documento.
Utilizar GPT-2 pasado
Y otros modelos (GPT, XLNet, Transfo XL, CTRL), el uso pasto memspropiedades que pueden ser utilizados para prevenir la tecla nuevo cálculo durante el uso de los pares de orden / valor de decodificación. Es útil en la generación de la secuencia, ya que una gran parte del mecanismo de atención gracias a los cálculos anteriores.
La siguiente es una banda de uso pastde GPT2LMHeadModelun ejemplo de trabajo completo y argmax decodificación (sólo como un ejemplo, porque un gran número de repetición introducido argmax Decoding):
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import torch
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained('gpt2')
generated = tokenizer.encode("The Manhattan bridge")
context = torch.tensor([generated])
past = None
for i in range(100):
print(i)
output, past = model(context, past=past)
token = torch.argmax(output[..., -1, :])
generated += [token.tolist()]
context = token.unsqueeze(0)
sequence = tokenizer.decode(generated)
print(sequence)Debido a que todos anterior par de claves marca / valor contenido dentro past, de modo que el modelo sólo necesita como entrada una marca.
ejemplo Model2Model
Coder - decodificador etiquetado arquitectura requiere dos entradas: una para el codificador, el descodificador para el otro. Supongamos que queremos usar la Model2Modelconducta preguntas generativas y respuestas, preguntas y respuestas de la muestra de que comenzó el modelo de entrada.
import torch
from transformers import BertTokenizer, Model2Model
# 可选：如果您想了解发生的信息，请按以下步骤logger
import logging
logging.basicConfig(level=logging.INFO)
# 加载预训练模型（权重）
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
# 编码输入（问题）
question = "Who was Jim Henson?"
encoded_question = tokenizer.encode(question)
# 编码输入（答案）
answer = "Jim Henson was a puppeteer"
encoded_answer = tokenizer.encode(answer)
# 将输入转换为PyTorch张量
question_tensor = torch.tensor([encoded_question])
answer_tensor = torch.tensor([encoded_answer])Veamos cómo Model2Modelobtener esta pérdida (pregunta, respuesta) del valor asociado con él:
#为了计算损失，我们需要向解码器提供语言模型标签（模型生成的标记id）。
lm_labels = encoded_answer
labels_tensor = torch.tensor([lm_labels])
# 加载预训练模型（权重）
model = Model2Model.from_pretrained('bert-base-uncased')
# 将模型设置为评估模式
# 在评估期间有可再现的结果这是很重要的！
model.eval()
# 如果你有GPU，把所有东西都放在cuda上
question_tensor = question_tensor.to('cuda')
answer_tensor = answer_tensor.to('cuda')
labels_tensor = labels_tensor.to('cuda')
model.to('cuda')
# 预测每个层的隐藏状态特征
with torch.no_grad():
# 有关输入的详细信息，请参见models文档字符串
outputs = model(question_tensor, answer_tensor, decoder_lm_labels=labels_tensor)
# Transformers模型总是输出元组。
# 有关所有输出的详细信息，请参见models文档字符串
# 在我们的例子中，第一个元素是LM损失的值
lm_loss = outputs[0]Esta pérdida puede ser utilizado para poner a punto la tarea preguntas y respuestas Model2Model. Supongamos que ajustar el modelo, ahora vamos a ver cómo generar respuestas:
# 让我们重复前面的问题
question = "Who was Jim Henson?"
encoded_question = tokenizer.encode(question)
question_tensor = torch.tensor([encoded_question])
# 这次我们试图生成答案，所以我们从一个空序列开始
answer = "[CLS]"
encoded_answer = tokenizer.encode(answer, add_special_tokens=False)
answer_tensor = torch.tensor([encoded_answer])
# 加载预训练模型（权重）
model = Model2Model.from_pretrained('fine-tuned-weights')
model.eval()
# 如果你有GPU，把所有东西都放在cuda上
question_tensor = question_tensor.to('cuda')
answer_tensor = answer_tensor.to('cuda')
model.to('cuda')
# 预测所有标记
with torch.no_grad():
outputs = model(question_tensor, answer_tensor)
predictions = outputs[0]
# 确认我们能预测“jim”
predicted_index = torch.argmax(predictions[0, -1]).item()
predicted_token = tokenizer.convert_ids_to_tokens([predicted_index])[0]
assert predicted_token == 'jim'Bienvenido atención Pan Chong blog en recursos estación Resumen: http://docs.panchuang.net/
oficial de bienvenida preocupación PyTorch estación Tutorial chino: http://pytorch.panchuang.net/
OpenCV documento oficial chino: http://woshicver.com/
