Analizziamo il Transformer

Modelli Transformer con PyTorch

James Chapman

Curriculum Manager, DataCamp

L'articolo che ha cambiato tutto...

Attention Is All You Need di Ashish Vaswani et al. (arXiv:1706.03762)
- Meccanismi di attenzione
- Ottimizzato per il text modeling
- Usato nei Large Language Models (LLMs)

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

L'articolo che ha cambiato tutto...

Attention Is All You Need di Ashish Vaswani et al.
- Meccanismi di attenzione
- Ottimizzato per il text modeling
- Usato nei Large Language Models (LLMs)

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

L'articolo che ha cambiato tutto...

Attention Is All You Need di Ashish Vaswani et al.
- Meccanismi di attenzione
- Ottimizzato per il text modeling
- Usato nei Large Language Models (LLMs)

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

Dentro il Transformer...

Blocco encoder

Più layer identici
Legge e elabora la sequenza in input
Genera rappresentazioni numeriche ricche di contesto
Usa self-attention e feed-forward networks

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

Dentro il Transformer...

Blocco decoder

Sequenza codificata → sequenza in output

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

Dentro il Transformer...

Positional encoding

Codifica la posizione di ogni token nella sequenza
L'ordine è cruciale per modellare le sequenze

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

Dentro il Transformer...

Meccanismi di attenzione

Si concentrano sui token importanti e sulle loro relazioni
Migliorano la generazione di testo

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

Dentro il Transformer...

Meccanismi di attenzione

Si concentrano sui token importanti e sulle loro relazioni
Migliorano la generazione di testo

Self-attention

Pesa l'importanza dei token
Cattura dipendenze di lungo raggio

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

Dentro il Transformer...

Meccanismi di attenzione

Si concentrano sui token importanti e sulle loro relazioni
Migliorano la generazione di testo

Self-attention

Pesa l'importanza dei token
Cattura dipendenze di lungo raggio

Multi-head attention

Divide l'input in più head
Le head colgono schemi diversi, producendo rappresentazioni più ricche

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

Dentro il Transformer...

Reti feed-forward position-wise

Sempliche NN che applicano trasformazioni
Ogni token è trasformato in modo indipendente
Indipendenti dalla posizione/"position-wise"

L'architettura dei Transformer come mostrata nell'articolo accademico Attention Is All You Need.

Transformer in PyTorch

d_model: Dimensione degli input del modello
nheads: Numero di head di attenzione
num_encoder_layers: Numero di layer dell'encoder
num_decoder_layers: Numero di layer del decoder

import torch.nn as nn


model = nn.Transformer(

    d_model=512,

    nhead=8,

    num_encoder_layers=6,

    num_decoder_layers=6

)


print(model)

Transformer(
  (encoder): TransformerEncoder(
    (layers): ModuleList(
      (0-5): 6 x TransformerEncoderLayer(
        (self_attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (linear1): Linear(in_features=512, out_features=2048, bias=True)
        (dropout): Dropout(p=0.1, inplace=False)
        (linear2): Linear(in_features=2048, out_features=512, bias=True)
        (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (dropout1): Dropout(p=0.1, inplace=False)
        (dropout2): Dropout(p=0.1, inplace=False)
      )
    )
    (norm): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
  )
  ...

  (decoder): TransformerDecoder(
    (layers): ModuleList(
      (0-5): 6 x TransformerDecoderLayer(
        (self_attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (multihead_attn): MultiheadAttention(
          (out_proj): NonDynamicallyQuantizableLinear(in_features=512, out_features=512, bias=True)
        )
        (linear1): Linear(in_features=512, out_features=2048, bias=True)
        (dropout): Dropout(p=0.1, inplace=False)
        (linear2): Linear(in_features=2048, out_features=512, bias=True)
        (norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (norm3): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (dropout1): Dropout(p=0.1, inplace=False)
        (dropout2): Dropout(p=0.1, inplace=False)
        (dropout3): Dropout(p=0.1, inplace=False)
      )
    )
    (norm): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
  )
)

Esercitiamoci!

Modelli Transformer con PyTorch