README.md

---
license: gpl-3.0
datasets:
- Mattimax/Little_ITA_60k
language:
- it
library_name: transformers
tags:
- DAC
- data-ai
- DATA-AI
- transformer
- experimental
new_version: Mattimax/PicoDAC-IT
---

# PicoDAC

![Logo di PicoDAC](https://huggingface.co/Mattimax/PicoDAC/resolve/main/PicoDAC_Logo/PicoDAC_Logo.png)

## Informazioni sul modello

- **Autore:** [Mattimax](https://huggingface.co/Mattimax)
- **Organizzazione:** [M.INC](https://huggingface.co/MINC01)
- **Pagina GitHub:** [PicoDAC](https://github.com/M-INC-01/PicoDAC/tree/main)
- **Licenza:** GPL-3.0

**Descrizione:**
PicoDAC è un modello di linguaggio compatto progettato per chat in lingua italiana. Basato su una architettura Transformer leggera, è ottimizzato per essere rapido e facilmente distribuibile. Questo modello è un **esperimento** ed è ancora in fase di sviluppo, quindi le prestazioni possono essere limitate rispetto a modelli più grandi e sofisticati.

**Dataset di addestramento:**
Il modello è stato addestrato sul dataset [Little_ITA_60k](https://huggingface.co/datasets/Mattimax/Little_ITA_60k), contenente conversazioni brevi in italiano.

**Obiettivo:**
Fornire un prototipo di chatbot italiano leggero, utile per test, sperimentazioni e applicazioni dove la dimensione del modello e la velocità sono prioritarie rispetto alla qualità generativa.

---

## Caratteristiche tecniche

* Architettura: Transformer autoregressivo compatto
* Dimensione del vocabolario: 1.920 token
* Lunghezza massima del contesto: 64 token
* Numero di strati (layers): 6
* Numero di teste di attenzione: 6
* Dimensione embedding: 240
* Quantizzazione: int8 per la maggior parte dei pesi, con embedding e layernorm ottimizzati a bit più alti

---

## Avvertenze e limitazioni

* Questo modello è **ancora sperimentale**: può generare risposte incoerenti o incomplete.
* Non è addestrato per conversazioni sensibili o contenuti critici.
* Performance su testi lunghi o conversazioni complesse sono limitate a causa della breve lunghezza del contesto e della piccola dimensione del modello.

---

## Uso previsto

* Chatbot sperimentali in italiano
* Applicazioni leggere dove la dimensione del modello è critica
* Prototipazione e testing di modelli di dialogo

**Nota:** consigliato l’uso con input brevi e contesti semplici.

---

## Installazione

```bash
pip install transformers torch
```

---

## Esempio di utilizzo in Python

```python
import torch
import torch.nn as nn
import torch.nn.functional as F
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from transformers import PreTrainedTokenizerFast
import os

# ----------------------------
# Config modello
# ----------------------------
VOCAB_SIZE = 1920
D_MODEL = 240
N_LAYERS = 6
N_HEADS = 6
D_HEAD = 40
D_FF = 960
N_CTX = 64

device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Usando device: {device}")

# ----------------------------
# Scarica tokenizer e modello da HF
# ----------------------------
repo_id = "Mattimax/PicoDAC"

tokenizer_path = hf_hub_download(repo_id, "tokenizer.json")
model_path = hf_hub_download(repo_id, "model.safetensors")
# opzionale: scales_path = hf_hub_download(repo_id, "best/scales.json")

# ----------------------------
# Carica tokenizer
# ----------------------------
tokenizer = PreTrainedTokenizerFast(tokenizer_file=tokenizer_path)
tokenizer.add_special_tokens({
    "pad_token": "<PAD>",
    "bos_token": "<BOS>",
    "eos_token": "<EOS>",
    "sep_token": "<SEP>",
    "unk_token": "<UNK>"
})

# ----------------------------
# RMSNorm
# ----------------------------
class RMSNorm(nn.Module):
    def __init__(self, dim, eps=1e-8):
        super().__init__()
        self.eps = eps
        self.weight = nn.Parameter(torch.ones(dim))
    
    def forward(self, x):
        norm = x.pow(2).mean(-1, keepdim=True).add(self.eps).sqrt()
        return x / norm * self.weight

# ----------------------------
# Transformer Block
# ----------------------------
class TransformerBlock(nn.Module):
    def __init__(self):
        super().__init__()
        self.ln1 = RMSNorm(D_MODEL)
        self.ln2 = RMSNorm(D_MODEL)
        self.attn = nn.MultiheadAttention(D_MODEL, N_HEADS, batch_first=True)
        self.ffn = nn.Sequential(
            nn.Linear(D_MODEL, D_FF),
            nn.SiLU(),
            nn.Linear(D_FF, D_MODEL)
        )
    
    def forward(self, x, mask=None):
        attn_out, _ = self.attn(self.ln1(x), self.ln1(x), self.ln1(x), attn_mask=mask)
        x = x + attn_out
        x = x + self.ffn(self.ln2(x))
        return x

# ----------------------------
# TinyGPT
# ----------------------------
class TinyGPT(nn.Module):
    def __init__(self):
        super().__init__()
        self.tok_emb = nn.Embedding(VOCAB_SIZE, D_MODEL)
        self.pos_emb = nn.Embedding(N_CTX, D_MODEL)
        self.layers = nn.ModuleList([TransformerBlock() for _ in range(N_LAYERS)])
        self.ln_f = RMSNorm(D_MODEL)
        self.head = nn.Linear(D_MODEL, VOCAB_SIZE, bias=False)
        self.head.weight = self.tok_emb.weight
    
    def forward(self, idx):
        B, T = idx.shape
        pos = torch.arange(T, device=idx.device).unsqueeze(0)
        x = self.tok_emb(idx) + self.pos_emb(pos)
        mask = torch.triu(torch.ones(T, T, device=idx.device) * float('-inf'), diagonal=1)
        for layer in self.layers:
            x = layer(x, mask=mask)
        x = self.ln_f(x)
        logits = self.head(x)
        return logits

# ----------------------------
# Carica pesi
# ----------------------------
state_dict = load_file(model_path)
model = TinyGPT()
model.load_state_dict(state_dict, strict=False)
model.to(device)
model.eval()

# ----------------------------
# Funzione generazione
# ----------------------------
def generate(prompt, max_new_tokens=50, temperature=0.7):
    model_input = tokenizer.encode(prompt, return_tensors="pt").to(device)
    for _ in range(max_new_tokens):
        logits = model(model_input)
        next_token_logits = logits[0, -1, :] / temperature
        probs = F.softmax(next_token_logits, dim=-1)
        next_token = torch.multinomial(probs, num_samples=1)
        model_input = torch.cat([model_input, next_token.unsqueeze(0)], dim=1)
        if next_token.item() == tokenizer.eos_token_id:
            break
    return tokenizer.decode(model_input[0], skip_special_tokens=True)

# ----------------------------
# Loop chat
# ----------------------------
print("Chat PicoDAC (scrivi 'exit' per uscire)")
while True:
    user_input = input("Tu: ").strip()
    if user_input.lower() in ["exit", "quit"]:
        print("Chiusura chat. Ciao!")
        break
    response = generate(user_input)
    print(f"PicoDAC: {response}")
```

**Suggerimenti pratici:**

* Usa `max_length` basso per mantenere la coerenza delle risposte.
* Temperature intorno a 0.7–1.0 favoriscono generazioni più creative.
* Evita input troppo lunghi (oltre 64 token), perché il modello può perdere il contesto precedente.

---

## Integrazione consigliata

* **Applicazioni mobile**: dimensione ridotta e quantizzazione riducono il consumo di RAM e storage.
* **Sperimentazione NLP**: utile per test di prompt, fine-tuning leggero o per costruire dataset sintetici.

---

## Riferimenti

* Dataset: [Little_ITA_60k](https://huggingface.co/datasets/Mattimax/Little_ITA_60k)
* Autore: [Mattimax](https://huggingface.co/Mattimax)
* Organizzazione: [M.INC](https://huggingface.co/MINC01)