Construiremos un modelo de lenguaje de regresión (RLM), un modelo que predice valores numéricos continuos directamente a partir de secuencias de texto en esta implementación de codificación. En lugar de clasificar o generar texto, nos centramos en la capacitación de una arquitectura basada en transformadores que aprende relaciones cuantitativas ocultas en las descripciones del lenguaje natural. Comenzamos generando datos sintéticos de texto a número, tokenizándolo de manera eficiente y luego entrenar a un codificador de transformador ligero para asignar señales lingüísticas a objetivos de valor real. Al final, no solo entendemos cómo se puede implementar RLMS desde cero, sino que también visualizamos su comportamiento de aprendizaje y pruebe su generalización en ejemplos invisibles. Mira los códigos completos aquí.
Comenzamos importando bibliotecas esenciales, como Pytorch, Numpy y Matplotlib, para construir y visualizar nuestro modelo de lenguaje de regresión. Establecemos semillas aleatorias para garantizar la reproducibilidad e inicializar el entorno, garantizando así resultados consistentes cada vez que se ejecuta el tutorial. Mira los códigos completos aquí.
(“The temperature is {} degrees”, lambda x: x),
(“I rate this {} out of ten”, lambda x: x),
(“The price is {} dollars”, lambda x: x),
(“Confidence level: {}”, lambda x: x / 100),
(“Speed of {} kilometers per hour”, lambda x: x / 10),
(“{} percent complete”, lambda x: x / 100),
(“Scored {} points in the game”, lambda x: x / 10),
(“The distance is {} meters”, lambda x: x),
]
Datos = []
para _ en rango (n_samples): plantlate, transform = plantlates[np.random.randint(len(templates))]
value = np.random.uniform (0, 100) text = Template.Format (redondear (valor, 1)) Target = transform (valor) data.append ((text, target)) devuelve datos
Creamos un conjunto de datos sintético que combina las oraciones del lenguaje natural con los valores numéricos correspondientes. Mediante el uso de plantillas variadas, como temperaturas, clasificaciones y porcentajes, nos aseguramos de que el modelo aprenda diversas relaciones de texto -número. Esta configuración controlada nos ayuda a simular tareas de regresión realistas sin depender de datos externos. Mira los códigos completos aquí.
Para texto en textos: words.extend (re.findall (r ‘\ w+|[^\w\s]’, text.lower ())) word_counts = contador (palabras) para palabras, _ en word_counts.most_common (): si word no en self.word2idx: self.word2idx[word] = self.vocab_size self.idx2word[self.vocab_size] = word self.vocab_size += 1 def coding (self, text, max_len = 20): “” “Convertir texto a índices de token” “” palabras = re.findall (r ‘\ w +|[^\w\s]’, text.lower ()) Indices = [self.word2idx.get(w, 1) for w in words]
Si len (índices)
Diseñamos un tokenizador simple para convertir el texto sin procesar en tokens numéricos que el modelo puede procesar. Construye un vocabulario a partir de todas las palabras únicas y asigna a un índice, manejando palabras desconocidas y acolchado automáticamente. Este paso asegura que nuestras entradas textuales se transformen en secuencias consistentes y legibles para la máquina para el entrenamiento. Mira los códigos completos aquí.
tokens = self.tokenizer.encode (text, self.max_len) return tortch.tensor (tokens), tortch.tensor ([target]dtype = TOTCH.FLOAT32) CLASE RESOURSIONLanGeGemodel (nn.module): def __init __ (self, vocab_size, incred_dim = 128, num_heads = 4, num_layers = 2, desaconsejado = 0.1, max_len = 20): super () .__ initer nn.Embedding(vocab_size, embed_dim, padding_idx=0) self.position_embedding = nn.Embedding(max_len, embed_dim) encoder_layer = nn.TransformerEncoderLayer( d_model=embed_dim, nhead=num_heads, dim_feedforward=embed_dim * 4, dropout=dropout, batch_first = true) self.transformer = nn.transformerEncoder (encoder_layer, num_layers = num_layers) self.fc1 = nn.linear (incrus_dim, 64) self.relu = nn.relu () self.dropout = nn.dropout (dropout) self.fc2 = nn.linear (64, 1, 1, 1, 1, 1) Self.max_len = max_len def hacia adelante (self, x): batch_size, seq_len = x.shape posicions = torc.arange (0, seq_len, dispositivo = x.device) .UnSqueeze (0) .EXPAND (batch_size, -1) token_embed = self.token_embedding (x) pos_position incrustaciones = token_embed + pos_embed padding_mask = (x == 0) encoded = self.transformer (incrusteos, src_key_padding_mask = padding_mask) mask_expanded = (~ padding_mask) .UnSqueeze (-1) .float () sumado = (encoded *_EXPANDYANDY) .sumed). MASK_EXPANDEST.SUM (dim = 1) x = self.fc1 (agrupado) x = self.relu (x) x = self.dropout (x) output = self.fc2 (x) Salida de retorno
Empaquetamos nuestros pares de texto y número en un conjunto de datos de Pytorch, donde tocamos cada oración y devolvemos los tensores listos para el lote. Luego construimos un RLM basado en transformador: token y incrustaciones posicionales que fluyen a través de un codificador de múltiples capas, tenemos tokens no acelerados y alimentamos el resultado a una pequeña cabeza de MLP para la regresión. En efecto, permitimos que el codificador aprenda señales numéricas del lenguaje, mientras que la cabeza las asigna a un solo valor continuo. Mira los códigos completos aquí.
print (f “\ n📊 entrenamiento en {dispositivo}”) print (“-” * 60) para la época en el rango (épocas): model.train () trenes_loss = 0 para tokens, objetivos en Train_Loader: Tokens, Targets = Tokens.to (dispositivo), Targets.To (dispositivo) óptimos óptimos loss.backward() optimizer.step() train_loss += loss.item() train_loss /= len(train_loader) train_losses.append(train_loss) model.eval() val_loss = 0 with torch.no_grad(): for tokens, targets in val_loader: tokens, targets = tokens.to(device), targets.to(device) outputs = modelo (tokens) Loss = criterion (salidas, objetivos) val_loss += Loss.item () val_loss /= len (val_loader) val_losses.append (val_loss) print (f “Epoch {Epoch +1: 2d} /{Epephs} | Pérdida de trenes: {Train_losss: .4f} | Val pérdida: {ValLoss:. Train_losses, val_losses
Entrenamos el modelo utilizando la pérdida de Adam y MSE en una GPU, si está disponible, iterando sobre mini lotes para respaldar y actualizar pesos. Cambiamos al modo de evaluación para su validación al final de cada época, seguimiento de capacitación y pérdidas de validación, e imprimiendo el progreso para que podamos ver la dinámica de aprendizaje en tiempo real. Mira los códigos completos aquí.
print (f “muestras de tren: {len (Train_data)}, Val muestras: {len (val_data)}”) print (“\ n🔤 tokenizer de edificios …”) tokenizer = simplizekokenizer () tokenizer.fit (Fit ([text for text, _ in train_data]) print (f “tamaño de vocabulario: {tokenizer.vocab_size}”) Train_dataset = rlmdataSet (Train_data, tokenizer) val_dataset = rlmdataset (val_data, tokenizer) Train_Loader = dataader (Train_dataSet, batch_size = 32, sholeLETER) DataLoader (val_dataset, batch_size = 32) print (“\ n🏗️ Modelo de lenguaje de regresión de construcción …”) Modelo = regresionLanguageModel (VOCAB_SIZE = TOKENIZER.VOCAB_SIZE) Impresa (F “Modelo de parámetros: {Sum (p.numel () para P en Model.parameters ()) :,}) Train_rlm (Model, Train_Loader, Val_Loader) plt.figure (figSize = (10, 4)) plt.plot (Train_losses, etiqueta = “pérdida de trenes”, linewidth = 2) plt.plot (val_losses, etiquetado = “Val pérdida”, Linewidth = 2) plt.xlabel (‘Epoch’) plt.ylabel (‘mse)’) plt.title (‘RLM Progress de entrenamiento’) plt.legend () plt.grid (true, alfa = 0.3) plt.show () imprimir (“\ n🎯 predicciones de prueba:”) print (“-” * 60) test_examples = [
“The temperature is 25.5 degrees”,
“I rate this 8.0 out of ten”,
“The price is 45.0 dollars”,
“75.0 percent complete”
]
con torc.no_grad (): para texto en test_examples: tokens = tortch.tensor ([tokenizer.encode(text)]) .to (dispositivo) predicción = modelo (tokens) .item () print (f “entrada: {text}”) print (f “valor predicho: {predicción: .4f} \ n”) print (“✅ tutorial rlm completo!”)
Generamos y dividimos datos sintéticos, se ajustamos a nuestro tokenizer, envolvemos todo en conjuntos de datos/cargadores de Pytorch, y construimos el RLM basado en transformadores. Entrenamos el modelo, visualizamos las curvas de pérdida para verificar el aprendizaje y luego ejecutamos algunas indicaciones de prueba de idioma natural para ver los valores continuos predichos. Con eso, completamos la tubería RLM de extremo a extremo.
En conclusión, diseñamos, capacitamos y evaluamos con éxito un modelo de lenguaje de regresión capaz de predecir valores continuos a partir de entradas textuales. Observamos cómo la combinación de incrustaciones posicionales, codificadores de transformadores y una cabeza de regresión simple permite que el modelo capture la semántica numérica incrustada en el lenguaje. Al generar datos sintéticos, visualizar el progreso del entrenamiento y probar predicciones, demostramos cómo los RLMs unen la brecha entre la comprensión del lenguaje y el razonamiento numérico.
Mira los códigos completos aquí. No dude en consultar nuestra página de GitHub para obtener tutoriales, códigos y cuadernos. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro subreddit de 100k+ ml y suscribirse a nuestro boletín. ¡Esperar! ¿Estás en Telegram? Ahora también puedes unirte a nosotros en Telegram.
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como empresario e ingeniero visionario, ASIF se compromete a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, MarktechPost, que se destaca por su cobertura profunda de noticias de aprendizaje automático y de aprendizaje profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el público.
🙌 Siga a MarkTechPost: agrégenos como una fuente preferida en Google.