Help de ontwikkeling van de site en deelt het artikel met vrienden!

Inleiding tot PyTorch Embedding

PyTorch Embedding is een ruimte met lage afmetingen waar hoogdimensionale vectoren gemakkelijk kunnen worden vertaald, zodat modellen kunnen worden hergebruikt voor nieuwe problemen en gemakkelijk kunnen worden opgelost. De wijzigingen worden in elk afzonderlijk videoframe bewaard, zodat de gegevens gemakkelijk in de videoframes kunnen worden verborgen wanneer er wijzigingen zijn. Maar de eerste stap is om te bepalen of we de gegevens willen verbergen of dat we de gegevens uit de videoframes moeten halen.

Wat is PyTorch Embedding?

  • Er moet een inbeddingslaag worden gemaakt waar de tensor wordt geïnitialiseerd op basis van de vereisten.
  • Als we het model nu trainen, vindt het overeenkomsten tussen woorden of getallen en geeft het ons de resultaten.
  • Als het model vooraf is getraind met een ander voorbeeld, geeft het ons resultaten van beide modellen.
  • Na de ingesloten laag moet de woordenschat worden gedefinieerd en deze instantie kan worden gebruikt om de juiste inbedding van de lagen op te halen.

Hoe werkt PyTorch Embedding?

  • We kunnen de inbeddingslaag een lineaire laag noemen waarbij de laag op deze manier nn.lineair is gedefinieerd (aantal woorden, dimensionale vectoren). Daarom beschrijven de woorden in de laag de vector van grootte 1000 met 1 in de normale positie. Als het een vector is met v(2)=1, dan krijgen we de 2e rij van de laag in hetzelfde experiment. Inbedding beschrijft hier de vectoren en lagen in de woordenschat.We kunnen een index geven zonder de hele vector te geven, waarbij de index de positie van de eerste vector in het experiment beschrijft.
  • Invoer van forward pass() heeft een lijst van indexen met woorden. Er zijn hier geen batches bij betrokken en daarom is het altijd één index die is toegewezen aan één woord. Dit helpt ons om lineair te gebruiken in plaats van insluiten zoals nn.linear(). Opgemerkt moet worden dat tijdens het gebruik van nn.linear, de invoer geen hot vectors hoeft te zijn, aangezien het alle woorden kunnen zijn die kunnen worden toegewezen met behulp van indexen. Er is geen onderliggende architectuur met inbedding omdat het altijd als een laag wordt beschouwd, en meestal is het een lineaire laag. Een woord komt altijd overeen met een vector, en daarom kunnen we het een M X N-matrix noemen, waarbij M overeenkomt met woorden en N met vector. Er is dus een één-op-één overeenkomst tussen woorden en vectoren.
  • De eerste laag is meestal een lineaire laag waar we afmetingen gemakkelijk kunnen verkleinen. Hier is één hete gecodeerde matrix niet nodig waar we alleen indices van woorden nodig hebben.Daarom heeft NLP altijd te maken met het inbedden van lagen, wat van groot belang is. Hier kunnen we een one-hot vector vermenigvuldigen met een inbeddingsmatrix die het probleem opzoekt. Terugvermeerdering is ook goed gedaan met inbeddingsmatrix.

Gebruik van PyTorch Embedding

  • Dit helpt ons om elk woord in de matrix om te zetten in een vector met een correct gedefinieerde grootte. We zullen het resultaat hebben waar er alleen nullen en enen in de vector zijn. Dit helpt ons om de vectoren weer te geven met afmetingen waarbij woorden helpen de afmetingen van de vector te verkleinen.
  • We kunnen zeggen dat de insluitlaag werkt als een opzoektabel waarin elk woord wordt geconverteerd naar getallen, en deze getallen kunnen worden gebruikt om de tabel op te maken. Sleutels worden dus weergegeven door woorden en de waarden zijn woordvectoren.
  • In NLP is inbedding erg handig bij het verkleinen van de afmetingen, zodat we het aantal kenmerken in de codering kunnen controleren. Dit helpt om het aantal regels in de code te verminderen, en daarom krijgen we sneller resultaten dan met meer functies en minder nauwkeurigheid.
  • Een ander gebruik van insluiten is dat het woorden met contexten verbindt. Dit helpt bij het verbinden van soortgelijke betekeniswoorden met vergelijkbare contexten, waardoor het werk met betrekking tot de hele woorden wordt verminderd om het met contexten te relateren.
  • Als we veel input hebben op het gebied van machine learning, is het moeilijk om hetzelfde te beheren, omdat het aantal woorden groter zal zijn, en het zal moeilijk zijn om met de woorden en gerelateerde contexten om te gaan. Inbedding helpt hier om woorden te verbinden met indexen, en daarom worden woorden gereduceerd tot getallen. Vervolgens zijn ze verbonden met contexten, en nu wordt de hele invoerstroom teruggebracht tot een paar contexten en minder woorden.

Parameters van PyTorch Embedding

Hieronder vindt u de parameters van PyTorch Embedding:

  • Aantal_embeddings: Dit vertegenwoordigt de grootte van het woordenboek dat aanwezig is in de inbeddingen, en het wordt weergegeven in gehele getallen.
  • Embedding_dim: Dit vertegenwoordigt de grootte van elke vector die aanwezig is in de inbeddingen, die wordt weergegeven in gehele getallen.
  • Max_norm: Dit is een optionele parameter die wordt weergegeven door een float. Elke inbedding wordt door deze parameter geleid en als deze groter is dan max_norm, wordt deze opnieuw genormaliseerd om de inbedding te vormen.
  • Scale_grad_by_freq: Dit is een optionele parameter met Booleaanse waarden waar het helpt om de gradiënten te schalen met de inverse in de frequentie van woorden die in de batch aanwezig zijn.

Voorbeeld van PyTorch-inbedding

Hieronder is het voorbeeld van PyTorch Embedding:

Code:

toorts importeren
importeer torch.nn als nn
importeer torch.nn.functioneel als Fun
importeer torch.optim als opt
torch.manual_seed(2)
"word_conversion={hey: 0, daar: 1}
"inbeddingen=nn.Inbedding(2, 3)
"lookup=torch.tensor((word_conversion(hey)), dtype=torch.long)
"hey_embeddings=embeddings(opzoeken)
print(hey_embeddings)
n, d, m=2, 4, 6
inbeddingen=nn.Inbedding(n, d, max_norm=True)
Gewicht=toorts.randn((m, d), required_grad=True)
index=toorts.tensor((1, 3))
x=insluiten.gewicht.clone() @ Gewicht.t()
y=insluiten (index) @ Gewicht.t()
output=(x.uitknijpen(1) + y.uitknijpen(2))
loss_factor=output.sigmoid().prod()
loss_factor.backward()
class NewModel(nn.Module):
def __init__(zelf, embed_size, embed_dimension):
super(NieuwModel, zelf).__init__()
zelf.embed_size=embed_size
zelf.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)
zelf.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=zelf.v_embeddings(pos_v)
score=torch.mul(embed_u, embed_v).squeeze()
score=torch.sum(score, dim=1)
score=F.logsigmoid(score)
neg_embed_v=zelf.v_embeddings(neg_v)
negtv_score=torch.bmm(neg_embed_v, embed_u.unsqueeze(2)).squeeze()
negtv_score=F.logsigmoid(-1negtv_score)
return -1(toorts.sum(score)+toorts.sum(negtv_score))

Conclusie

Inbedding helpt om woorden met cijfers te verbinden, en dus wordt de helft van het werk verminderd met betrekking tot NLP en machine learning. Het is echter belangrijk om de afmetingen te noteren en de woorden te beheren zodat ze correct worden geïndexeerd en beheerd.

Help de ontwikkeling van de site en deelt het artikel met vrienden!

Categorie:

Basisprincipes van gegevensanalyse