Ajude o desenvolvimento do site, compartilhando o artigo com os amigos!

Introdução à incorporação do PyTorch

PyTorch Embedding é um espaço com baixas dimensões onde vetores de alta dimensão podem ser traduzidos facilmente para que os modelos possam ser reutilizados em novos problemas e possam ser resolvidos facilmente. As alterações são mantidas em cada quadro de vídeo para que os dados possam ser ocultados facilmente nos quadros de vídeo sempre que houver alterações. Mas o primeiro passo é determinar se queremos ocultar os dados ou precisamos extrair os dados dos quadros de vídeo.

O que é incorporação do PyTorch?

  • Uma camada de incorporação deve ser criada onde o tensor é inicializado com base nos requisitos.
  • Agora, quando treinamos o modelo, ele encontra semelhanças entre palavras ou números e nos dá os resultados.
  • Se o modelo for pré-treinado com outro exemplo, ele nos dará resultados de ambos os modelos.
  • Após a camada incorporada, o vocabulário deve ser definido, e esta instância pode ser usada para buscar a incorporação correta das camadas.

Como funciona a incorporação do PyTorch?

  • Podemos chamar a camada de incorporação como uma camada linear onde a camada é definida desta maneira nn.linear (número de palavras, vetores dimensionais). Assim, as palavras na camada descrevem o vetor de tamanho 1000 com 1 na posição normal. Se for um vetor com v(2)=1, obtemos a 2ª linha da camada no mesmo experimento. Aqui, a incorporação descreve os vetores e as camadas no vocabulário das palavras.Podemos dar um índice sem dar o vetor inteiro onde o índice descreve a posição do 1º vetor no experimento.
  • As entradas de forward pass() possuem uma lista de índices com palavras. Não há lotes envolvidos aqui e, portanto, é sempre um índice mapeado para uma palavra. Isso nos ajuda a usar linear em vez de incorporar como nn.linear(). Deve-se notar que ao usar nn.linear, as entradas não precisam ser vetores quentes, pois podem ser quaisquer palavras que podem ser mapeadas usando índices. Não há arquitetura subjacente com incorporação, pois sempre é considerada uma camada e, principalmente, é uma camada linear. Uma palavra sempre corresponde a um vetor e, portanto, podemos chamá-la de matriz M X N, onde M corresponde a palavras e N a vetor. Portanto, há uma correspondência um-para-um entre palavras e vetores.
  • A primeira camada é principalmente uma camada linear onde podemos reduzir as dimensões facilmente. Aqui não é necessária uma matriz codificada a quente onde precisamos apenas de índices de palavras.Portanto, a PNL sempre lida com camadas de incorporação, o que é de grande importância. Aqui podemos multiplicar um vetor one-hot com uma matriz de incorporação que faz a pesquisa para o problema. A retropropagação também é bem feita com matriz de incorporação.

Usos da incorporação do PyTorch

  • Isso nos ajuda a converter cada palavra presente na matriz em um vetor com um tamanho devidamente definido. Teremos o resultado onde há apenas 0’s e 1’s no vetor. Isso nos ajuda a representar os vetores com dimensões onde as palavras ajudam a reduzir as dimensões do vetor.
  • Podemos dizer que a camada de incorporação funciona como uma tabela de consulta onde cada palavra é convertida em números, e esses números podem ser usados para compor a tabela. Assim, as chaves são representadas por palavras e os valores são vetores de palavras.
  • Na PNL, a incorporação é muito útil para reduzir as dimensões para que possamos controlar o número de recursos na codificação. Isso ajuda a reduzir o número de linhas no código e, portanto, obtemos resultados mais rápidos do que com mais recursos e menos precisão.
  • Outro uso da incorporação é que ela conecta palavras com contextos. Isso ajuda a conectar palavras de significado semelhante com contextos semelhantes, reduzindo assim o trabalho relacionado às palavras inteiras para relacioná-las com contextos.
  • Quando temos grandes entradas em aprendizado de máquina, é difícil gerenciar o mesmo, pois o número de palavras será maior, e será difícil lidar com as palavras e contextos relacionados. A incorporação ajuda aqui a conectar palavras a índices e, portanto, as palavras são reduzidas a números. Em seguida, eles são conectados a contextos e agora todo o fluxo de entrada é reduzido a alguns contextos e a um número menor de palavras.

Parâmetros de incorporação do PyTorch

Abaixo estão os parâmetros do PyTorch Embedding:

  • Num_embeddings: Representa o tamanho do dicionário presente nos embeddings, e é representado em números inteiros.
  • Embedding_dim: Isso representa o tamanho de cada vetor presente nos embeddings, que é representado em números inteiros.
  • Max_norm: Este é um parâmetro opcional que é representado por um float. Cada incorporação é passada através deste parâmetro onde se for maior que max_norm, é renormalizado para formar a incorporação.
  • Scale_grad_by_freq: Este é um parâmetro opcional com valores booleanos onde ajudará a dimensionar os gradientes com o inverso da frequência das palavras presentes no lote.

Exemplo de incorporação do PyTorch

Abaixo está o exemplo de incorporação do PyTorch:

Código:

tocha de importação
import torch.nn como nn
import torch.nn.functional as Fun
import torch.optim como opt
tocha.manual_seed(2)
"word_conversion={hey: 0, lá: 1}
"embeddings=nn.Embedding(2, 3)
"lookup=tocha.tensor((word_conversion(hey)), dtype=torch.long)
"hey_embeddings=embeddings(pesquisa)
print(hey_embeddings)
n, d, m=2, 4, 6
embeddings=nn.Embedding(n, d, max_norm=True)
Peso=tocha.randn((m, d), require_grad=True)
índice=tocha.tensor((1, 3))
x=incorporação.peso.clone() @ Peso.t()
y=incorporação(índice) @ Weight.t()
output=(x.unsqueeze(1) + y.unsqueeze(2))
fator_perda=output.sigmoid().prod()
loss_factor.backward()
class NovoModelo(nn.Módulo):
def __init__(self, embed_size, embed_dimension):
super(NewModel, self).__init__()
self.embed_size=embed_size
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(self):
initrange=0,75 / self.embed_dimension
self.u_embeddings.weight.data.uniform_(-initrange, initrange)
self.v_embeddings.weight.data.uniform_(-0, 0)
def forward(self, pos_u, pos_v, neg_v):
embed_u=self.u_embeddings(pos_u)
embed_v=self.v_embeddings(pos_v)
pontuação=tocha.mul(incorporar_u, incorporar_v).squeeze()
pontuação=tocha.sum(pontuação, dim=1)
pontuação=F.logsigmoid(pontuação)
neg_embed_v=self.v_embeddings(neg_v)
negtv_score=torch.bmm(neg_embed_v, embed_u.unsqueeze(2)).squeeze()
negtv_score=F.logsigmoid(-1negtv_score)
return -1(torch.sum(score)+torch.sum(negtv_score))

Conclusão

Embedding ajuda a conectar palavras com números e, portanto, metade do trabalho é reduzido relacionado à PNL e aprendizado de máquina. No entanto, é importante observar as dimensões e gerenciar as palavras para que sejam indexadas e gerenciadas adequadamente.

Ajude o desenvolvimento do site, compartilhando o artigo com os amigos!

Categoria:

Noções básicas de análise de dados