Diez formas de utilizar incrustaciones para tareas tabulares de aprendizaje automático
Imagen del editor
Introducción
Las incrustaciones (representaciones numéricas basadas en vectores de datos típicamente no estructurados como texto) se han popularizado principalmente en el campo del procesamiento del lenguaje natural (PLN). Pero también son una herramienta poderosa para representar o complementar datos tabulares en otros flujos de trabajo de aprendizaje automático. Los ejemplos no sólo se aplican a datos de texto, sino también a categorías con un alto nivel de diversidad de propiedades semánticas latentes.
Este artículo descubre diez usos interesantes de las incorporaciones para aprovechar al máximo los datos en una variedad de tareas, modelos o proyectos de aprendizaje automático en su conjunto.
Configuración inicial: algunas de las 10 estrategias que se describen a continuación estarán acompañadas de breves extractos de código ilustrativos. Primero se proporciona un conjunto de datos de juguetes de ejemplo utilizado en los ejemplos, junto con las importaciones más básicas y comunes necesarias en la mayoría de ellos.
import pandas as pd
import numpy as np
# Example customer reviews’ toy dataset
df = pd.DataFrame({
“user_id”: [101, 102, 103, 101, 104],
“product”: [“Phone”, “Laptop”, “Tablet”, “Laptop”, “Phone”],
“category”: [“Electronics”, “Electronics”, “Electronics”, “Electronics”, “Electronics”],
“review”: [“great battery”, “fast performance”, “light weight”, “solid build quality”, “amazing camera”],
“rating”: [5, 4, 4, 5, 5]
})
import pandas as pd
import numpy as np
# Example customer reviews’ toy dataset
df = pd . DataFrame ( {
“user_id” : [ 101 , 102 , 103 , 101 , 104 ] ,
“product” : [ “Phone” , “Laptop” , “Tablet” , “Laptop” , “Phone” ] ,
“category” : [ “Electronics” , “Electronics” , “Electronics” , “Electronics” , “Electronics” ] ,
“review” : [ “great battery” , “fast performance” , “light weight” , “solid build quality” , “amazing camera” ] ,
“rating” : [ 5 , 4 , 4 , 5 , 5 ]
} )
1. Codificación de características categóricas con incrustaciones
Este es un enfoque útil en aplicaciones como sistemas de recomendación. En lugar de manejarse numéricamente, las características categóricas de alta cardinalidad, como los ID de usuarios y productos, se convierten mejor en representaciones vectoriales. Este enfoque se ha aplicado ampliamente y se ha demostrado que captura eficazmente los aspectos semánticos y las relaciones entre usuarios y productos.
Este ejemplo práctico define un par de capas de incrustación como parte de un modelo de red neuronal que toma descriptores de usuario y producto y los convierte en incrustaciones.
from tensorflow.keras.layers import Input, Embedding, Flatten, Dense, Concatenate
from tensorflow.keras.models import Model
# Numeric and categorical
user_input = Input(shape=(1,))
user_embed = Embedding(input_dim=500, output_dim=8)(user_input)
user_vec = Flatten()(user_embed)
prod_input = Input(shape=(1,))
prod_embed = Embedding(input_dim=50, output_dim=8)(prod_input)
prod_vec = Flatten()(prod_embed)
concat = Concatenate()([user_vec, prod_vec])
output = Dense(1)(concat)
model = Model([user_input, prod_input], output)
model.compile(“adam”, “mse”)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from tensorflow . keras . layers import Input , Embedding , Flatten , Dense , Concatenate
from tensorflow . keras . models import Model
# Numeric and categorical
user_input = Input ( shape = ( 1 , ) )
user_embed = Embedding ( input_dim = 500 , output_dim = 8 ) ( user_input )
usuario_vec = Aplanar ( ) ( user_embed )
entrada_producto = Entrada ( forma = ( 1 , ) )
prod_embed = Incrustar ( input_dim = 50 , salida_dim = 8 ) ( prod_entrada )
prod_vec = Aplanar ( ) ( prod_embed )
concat = Concatenar ( ) ( [ user_vec , prod_vec ] )
producción = Denso ( 1 ) ( concat )
modelo = Modelo ( [ entrada_usuario , entrada_producto ] , producción )
modelo . compilar ( "adán" , "mse" )
2. Promedio de incrustaciones de palabras para columnas de texto
Este enfoque comprime múltiples textos de longitud variable en incrustaciones de tamaño fijo agregando incrustaciones de palabras dentro de cada secuencia de texto. Se parece a uno de los usos más comunes de las incrustaciones; El giro aquí es agregar incrustaciones a nivel de palabra en una incrustación a nivel de oración o texto.
El siguiente ejemplo utiliza Gensim, que implementa el popular algoritmo Word2Vec para convertir unidades lingüísticas (normalmente palabras) en incrustaciones y realiza una agregación de múltiples incrustaciones a nivel de palabra para crear una incrustación asociada con cada reseña de usuario.
from gensim.models import Word2Vec
# Train embeddings on the review text
sentences = df[“review”].str.lower().str.split().tolist()
w2v = Word2Vec(sentences, vector_size=16, min_count=1)
df[“review_emb”] = df[“review”].apply(
lambda t: np.mean([w2v.wv[w] for w in t.lower().split()], axis=0)
)
from gensim . models import Word2Vec
# Train embeddings on the review text
sentences = df [ “review” ] . str . lower ( ) . str . split ( ) . tolist ( )
w2v = Word2Vec ( sentences , vector_size = 16 , min_count = 1 )
df [ “review_emb” ] = df [ “review” ] . apply (
lambda t : np . mean ( [ w2v . wv [ w ] for w in t . lower ( ) . split ( ) ] , axis = 0 )
)
3. Agrupación de incrustaciones en metacaracterísticas
Apilar verticalmente múltiples vectores de incrustación individuales en una matriz NumPy 2D (una matriz) es el paso principal para realizar la agrupación en un conjunto de incrustaciones de reseñas de clientes e identificar agrupaciones naturales que podrían relacionarse con temas en el conjunto de revisión. Esta técnica captura grupos semánticos generales y puede producir características categóricas informativas nuevas.
from sklearn.cluster import KMeans
emb_matrix = np.vstack(df[“review_emb”].values)
km = KMeans(n_clusters=3, random_state=42).fit(emb_matrix)
df[“review_topic”] = km.labels_
from sklearn . cluster import KMeans
emb_matrix = np . vstack ( df [ “review_emb” ] . values )
kilómetros = KMeans ( n_clusters = 3 , estado_aleatorio = 42 ) . encajar ( emb_matrix )
df [ "tema_revisión" ] = km . etiquetas_
4. Aprendizaje de incrustaciones tabulares autosupervisadas
Por sorprendente que parezca, aprender representaciones vectoriales numéricas de datos estructurados (particularmente para conjuntos de datos sin etiquetar) es una forma inteligente de convertir un problema no supervisado en un problema de aprendizaje autosupervisado: los datos mismos generan señales de entrenamiento.
Si bien estos enfoques son un poco más elaborados que el alcance práctico de este artículo, comúnmente utilizan una de las siguientes estrategias:
Predicción de características enmascaradas: oculta aleatoriamente los valores de algunas características, similar al modelado de lenguaje enmascarado para entrenar modelos de lenguaje grandes (LLM), lo que obliga al modelo a predecirlos en función de las características visibles restantes. Detección de perturbaciones: exponga el modelo a una variante ruidosa de los datos, con algunos valores de características intercambiados o reemplazados, y establezca el objetivo del entrenamiento para identificar qué valores son "legítimos" y cuáles han sido alterados.
5. Creación de incrustaciones categóricas con múltiples etiquetas
Este es un enfoque sólido para evitar errores de tiempo de ejecución cuando ciertas categorías no están en el vocabulario utilizado por algoritmos de incrustación como Word2Vec, manteniendo al mismo tiempo la usabilidad de las incrustaciones.
Este ejemplo representa una sola categoría como "Teléfono" usando múltiples etiquetas como "móvil" o "táctil". Crea una incrustación semántica compuesta agregando las incrustaciones de etiquetas asociadas. En comparación con las codificaciones categóricas estándar como one-hot, este método captura la similitud con mayor precisión y aprovecha el conocimiento más allá de lo que Word2Vec "sabe".
tags = {
“Phone”: [“mobile”, “touch”],
“Laptop”: [“portable”, “cpu”],
“Tablet”:[]# Agregado para manejar el producto 'Tableta' } def safe_mean_embedding(words, model, dim): vecs = [model.wv[w] for w en palabras si w en model.wv] return np.mean(vecs, axis=0) if vecs else np.zeros(dim) df["tag_emb"] = df["product"].apply( lambda p: safe_mean_embedding(etiquetas[p], w2v, 16))
etiquetas = {
"Teléfono" : [ "móvil" , "tocar" ] ,
"Computadora portátil" : [ "portátil" , "UPC" ] ,
"Tableta" : [ ] # Agregado para manejar el producto 'Tableta'
}
def safe_mean_embedding ( palabras , modelo , tenue ) :
vecs = [ modelo . wv [ w ] para w en palabras si w en modelo . wv ]
devolver np . significa ( vecs , eje = 0 ) si vecs más np . ceros ( tenues )
df [ "tag_emb" ] = df [ "producto" ] . aplicar (
lambda pag : safe_mean_embedding ( etiquetas [ p ] , w2v , 16 )
)
6. Uso de incrustaciones contextuales para características categóricas
Este enfoque un poco más sofisticado primero asigna variables categóricas a incrustaciones "estándar" y luego las pasa a través de capas de autoatención para producir incrustaciones enriquecidas en contexto. Estas representaciones dinámicas pueden cambiar entre instancias de datos (por ejemplo, reseñas de productos) y capturar dependencias entre atributos, así como interacciones de características de orden superior. En otras palabras, esto permite que los modelos posteriores interpreten una categoría de manera diferente según el contexto, es decir, los valores de otras características.
7. Aprendizaje de incrustaciones en funciones numéricas agrupadas
Es común convertir características numéricas detalladas como la edad en contenedores (por ejemplo, grupos de edad) como parte del preprocesamiento de datos. Esta estrategia produce incrustaciones de características agrupadas, que pueden capturar valores atípicos o estructuras no lineales subyacentes a la característica numérica original.
En este ejemplo, la característica de calificación numérica se convierte en una contraparte agrupada y luego una capa de incrustación neuronal aprende una representación vectorial 3D única para diversos rangos de calificación.
bins = pd.cut(df[“rating”], bins=4, labels=False)
emb_numeric = Embedding(input_dim=4, output_dim=3)(Input(shape=(1,)))
contenedores = PD . cortar ( df [ "calificación" ] , contenedores = 4 , etiquetas = Falso )
emb_numeric = Incrustar ( input_dim = 4 , salida_dim = 3 ) ( Entrada ( forma = ( 1 , ) ) )
8. Fusión de incrustaciones y funciones sin procesar (funciones de interacción)
Supongamos que encuentra una etiqueta que no se encuentra en Word2Vec (por ejemplo, un nombre de producto como "Teléfono"). Este enfoque combina incorporaciones semánticas previamente entrenadas con características numéricas sin procesar en un único vector de entrada.
Este ejemplo primero obtiene una representación incrustada de 16 dimensiones para nombres de productos categóricos y luego agrega calificaciones sin procesar. Para el modelado posterior, esto ayuda al modelo a comprender ambos productos y cómo se perciben (por ejemplo, sentimiento).
df[“product_emb”] = df[“product”].str.lower().apply(
lambda p: w2v.wv[p] if p in w2v.wv else np.zeros(16)
)
df[“user_product_emb”] = df.apply(
lambda r: np.concatenate([r[“product_emb”], [r[“rating”]]]),
axis=1
)
df [ “product_emb” ] = df [ “product” ] . str . lower ( ) . apply (
lambda p : w2v . wv [ p ] if p in w2v . wv else np . zeros ( 16 )
)
df [ “user_product_emb” ] = df . apply (
lambda r : np . concatenate ( [ r [ “product_emb” ] , [ r [ “rating” ] ] ] ) ,
axis = 1
)
9. Uso de incrustaciones de oraciones para textos largos
Los transformadores de oraciones convierten secuencias completas, como revisiones de texto, en vectores de incrustación que capturan la semántica a nivel de secuencia. Con un pequeño giro (convertir una reseña en una lista de vectores) transformamos el texto no estructurado en atributos de ancho fijo que los modelos pueden usar junto con las columnas tabulares clásicas.
from sentence_transformers import SentenceTransformer
model = SentenceTransformer(“sentence-transformers/all-MiniLM-L6-v2”)
df[“sent_emb”] = list(model.encode(df[“review”].tolist()))
from sentence_transformers import SentenceTransformer
model = SentenceTransformer ( “sentence-transformers/all-MiniLM-L6-v2” )
df [ “sent_emb” ] = list ( model . encode ( df [ “review” ] . tolist ( ) ) )
10. Introducir incrustaciones en modelos de árboles
La estrategia final combina el aprendizaje de representaciones con el aprendizaje de datos tabulares en un enfoque de fusión híbrida. De manera similar al elemento anterior, las incrustaciones que se encuentran en una sola columna se expanden en varias columnas de características. La atención se centra aquí no en cómo se crean las incorporaciones, sino en cómo se utilizan y se introducen en un modelo posterior junto con otros datos.
import xgboost as xgb
X = pd.concat(
[pd.DataFrame(df[“review_emb”].tolist()), df[[“rating”]]],
axis=1
)
y = df[“rating”]
model = xgb.XGBRegressor()
model.fit(X, y)
import xgboost as xgb
X = pd . concat (
[ pd . Marco de datos ( df [ "review_emb" ] . tolist ( ) ) , df [ [ "calificación" ] ] ] ,
eje = 1
)
y = df [ "calificación" ]
modelo = xgb . XGBRegresor ( )
modelo . encajar ( X , y )
Comentarios finales
Las incrustaciones no son simplemente una cuestión de PNL. Este artículo mostró una variedad de usos posibles de incrustaciones (con poco o ningún esfuerzo adicional) que pueden fortalecer los flujos de trabajo de aprendizaje automático al desbloquear la similitud semántica entre ejemplos, proporcionar un modelado de interacción más rico y producir representaciones de características compactas e informativas.