¡Ayuda al desarrollo del sitio, compartiendo el artículo con amigos!

Introducción a la incrustación de PyTorch

PyTorch Embedding es un espacio con dimensiones bajas donde los vectores de dimensiones altas se pueden traducir fácilmente para que los modelos se puedan reutilizar en nuevos problemas y se puedan resolver fácilmente. Los cambios se mantienen en cada cuadro de video individual para que los datos se puedan ocultar fácilmente en los cuadros de video siempre que haya cambios. Pero el primer paso es determinar si deseamos ocultar los datos o si necesitamos extraer los datos de los cuadros de video.

¿Qué es la incrustación de PyTorch?

  • Se debe crear una capa incrustada donde el tensor se inicialice según los requisitos.
  • Ahora, cuando entrenamos el modelo, encuentra similitudes entre palabras o números y nos da los resultados.
  • Si el modelo se entrena previamente con otro ejemplo, nos dará resultados de ambos modelos.
  • Después de la capa incrustada, se debe definir el vocabulario, y esta instancia se puede usar para obtener la incrustación correcta de las capas.

¿Cómo funciona la incrustación de PyTorch?

  • Podemos llamar a la capa de incrustación como una capa lineal donde la capa se define de esta manera nn.linear (número de palabras, vectores dimensionales). Por lo tanto, las palabras en la capa describen el vector de tamaño 1000 con 1 en la posición normal. Si es un vector con v(2)=1, entonces obtenemos la segunda fila de la capa en el mismo experimento. Aquí la incrustación describe los vectores y las capas en el vocabulario de las palabras.Podemos dar un índice sin dar el vector completo donde el índice describe la posición del primer vector en el experimento.
  • Las entradas de forward pass() tienen una lista de índices con palabras. No hay lotes involucrados aquí y, por lo tanto, siempre es un índice asignado a una palabra. Esto nos ayuda a usar lineal en lugar de incrustar como nn.linear(). Cabe señalar que al usar nn.linear, las entradas no necesitan ser vectores calientes, ya que pueden ser palabras que se pueden mapear usando índices. No existe una arquitectura subyacente con la incrustación, ya que siempre se considera como una capa y, en su mayoría, es una capa lineal. Una palabra siempre coincide con un vector y, por lo tanto, podemos llamarla matriz M X N, donde M corresponde a palabras y N a vector. Entonces hay una correspondencia uno a uno entre palabras y vectores.
  • La primera capa es principalmente una capa lineal donde podemos reducir las dimensiones fácilmente. Aquí no se necesita una matriz codificada en caliente donde solo necesitamos índices de palabras.Por lo tanto, la PNL siempre trata con capas incrustadas, lo cual es de gran importancia. Aquí podemos multiplicar un vector caliente con una matriz incrustada que realiza la búsqueda del problema. La retropropagación también funciona bien con la matriz incrustada.

Usos de la incrustación de PyTorch

  • Esto nos ayuda a convertir cada palabra presente en la matriz en un vector con un tamaño correctamente definido. Tendremos el resultado donde solo hay 0 y 1 en el vector. Esto nos ayuda a representar los vectores con dimensiones donde las palabras ayudan a reducir las dimensiones del vector.
  • Podemos decir que la capa incrustada funciona como una tabla de búsqueda donde cada palabra se convierte en números, y estos números se pueden usar para formar la tabla. Por lo tanto, las claves están representadas por palabras y los valores son vectores de palabras.
  • En NLP, la incrustación es muy útil para reducir las dimensiones de modo que podamos controlar la cantidad de funciones en la codificación. Esto ayuda a reducir la cantidad de líneas en el código y, por lo tanto, obtenemos resultados más rápido que con más funciones y menos precisión.
  • Otro uso de la incrustación es que conecta palabras con contextos. Esto ayuda a conectar palabras de significado similar con contextos similares, reduciendo así el trabajo relacionado con las palabras completas para relacionarlas con contextos.
  • Cuando tenemos grandes entradas en el aprendizaje automático, es difícil administrar lo mismo, ya que la cantidad de palabras será mayor y será difícil manejar las palabras y los contextos relacionados. La incrustación ayuda aquí a conectar palabras con índices y, por lo tanto, las palabras se reducen a números. Luego se conectan con contextos, y ahora todo el flujo de entrada se reduce a unos pocos contextos y menos número de palabras.

Parámetros de incrustación de PyTorch

A continuación se muestran los parámetros de PyTorch Embedding:

  • Num_embeddings: Esto representa el tamaño del diccionario presente en las incrustaciones, y se representa en números enteros.
  • Embedding_dim: Esto representa el tamaño de cada vector presente en las incrustaciones, que se representa en números enteros.
  • Max_norm: Este es un parámetro opcional que está representado por un flotador. Cada incrustación se pasa a través de este parámetro donde, si es mayor que max_norm, se vuelve a normalizar para formar la incrustación.
  • Scale_grad_by_freq: Este es un parámetro opcional con valores booleanos donde ayudará a escalar los gradientes con el inverso de la frecuencia de las palabras presentes en el lote.

Ejemplo de incrustación de PyTorch

A continuación se muestra el ejemplo de PyTorch Embedding:

Código:

importar antorcha
importar torch.nn como nn
importar torch.nn.funcional como Fun
importar torch.optim como opt
antorcha.manual_seed(2)
"word_conversion={hey: 0, allí: 1}
"incrustaciones=nn.Incrustaciones(2, 3)
"búsqueda=antorcha.tensor((palabra_conversión(hey)), dtype=torcha.largo)
"hey_embeddings=incrustaciones(búsqueda)
imprimir(hey_incrustaciones)
norte, re, metro=2, 4, 6
incorporaciones=nn.Embedding(n, d, max_norm=True)
Peso=antorcha.randn((m, d), require_grad=True)
índice=antorcha.tensor((1, 3))
x=incrustación.peso.clone() @ Peso.t()
y=incrustación(índice) @ Peso.t()
salida=(x.unsqueeze(1) + y.unsqueeze(2))
factor_pérdida=salida.sigmoide().prod()
loss_factor.backward()
clase NuevoModelo(nn.Módulo):
def __init__(self, incrustar_tamaño, incrustar_dimensión):
super(NuevoModelo, propio).__init__()
self.embed_size=incrustar_tamaño
self.embed_dimension=embed_dimension
self.u_embeddings=nn.Embedding(embed_size, embed_dimension, sparse=True)
self.v_embeddings=nn.Embedding(embed_size, embed_dimension, sparse=True)
self.init_embed()
def init_embed(auto):
initrange=0.75 / self.embed_dimension
self.u_embeddings.weight.data.uniform_(-initrange, initrange)
self.v_incrustaciones.peso.datos.uniforme_(-0, 0)
def adelante(self, pos_u, pos_v, neg_v):
incrustar_u=self.u_incrustaciones(pos_u)
incrustar_v=self.v_incrustaciones(pos_v)
puntuación=antorcha.mul(incrustar_u, incrustar_v).apretar()
puntuación=antorcha.sum(puntuación, dim=1)
puntuación=F.logsigmoid(puntuación)
neg_embed_v=self.v_embeddings(neg_v)
negtv_score=torch.bmm(neg_embed_v, embed_u.unsqueeze(2)).squeeze()
puntuación_negatv=F.logsigmoid(-1puntuación_negatv)
return -1(torch.sum(puntaje)+torch.sum(negtv_score))

Conclusión

La incrustación ayuda a conectar palabras con números y, por lo tanto, se reduce la mitad del trabajo relacionado con la PNL y el aprendizaje automático. Sin embargo, es importante tener en cuenta las dimensiones y administrar las palabras para que se indexen y administren correctamente.

¡Ayuda al desarrollo del sitio, compartiendo el artículo con amigos!

Categoría:

Conceptos básicos de análisis de datos