☕ Support my research

Mattimax/DACMini-IT

• Autore: Mattimax
• Organizzazione: M.INC
• Licenza: MIT

---

Descrizione

DACMini-IT è un modello di linguaggio compatto e instruction tuned per chat e dialogo in lingua italiana. Basato sull’architettura GPT-2 Small (italian adaptation), è progettato per essere rapido, leggero e facilmente distribuibile su dispositivi con risorse limitate.

Rispetto a DACMini “base”, DACMini-IT è addestrato su dataset italiani conversazionali strutturati in formato user-assistant, ottimizzando la capacità di seguire istruzioni e gestire conversazioni multi-turno naturali.

---

Dimensioni e caratteristiche tecniche

• Parametri: 109M
• Architettura: GPT-2 Small (italian adaptation)
• Lunghezza massima del contesto: 512 token
• Numero di strati: 12
• Numero di teste di attenzione: 12
• Dimensione embedding: 768
• Vocabolario: ~50.000 token
• Quantizzazione: supportata (8-bit / 4-bit opzionale con bitsandbytes)

---

Dataset di addestramento

Addestrato su Mattimax/DATA-AI_Conversation_ITA, un dataset italiano di dialoghi instruction tuned, contenente coppie prompt-response strutturate per favorire risposte coerenti, naturali e grammaticalmente corrette.

---

Obiettivi

• Chatbot in lingua italiana con capacità di seguire istruzioni.
• Risposte concise, chiare e naturali in contesti multi-turno.
• Applicazioni leggere o offline dove la dimensione del modello è un vincolo.

---

Avvertenze e limitazioni

• Modello sperimentale: può produrre errori logici o risposte non pertinenti.
• Non addestrato su temi sensibili o contenuti specialistici.
• Prestazioni limitate su conversazioni molto lunghe o prompt complessi.
• Non destinato ad usi commerciali senza ulteriore validazione.

---

Uso consigliato

• Applicazioni chatbot leggere o offline in italiano.
• Prototipazione e test di pipeline NLP italiane.
• Generazione di risposte sintetiche e dataset per training o valutazione.

---

Codice per inferenza di esempio

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 1. Carica modello e tokenizer addestrati
model_path = "Mattimax/DACMini-IT"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path)
model.eval()

# 2. Funzione di generazione
def chat_inference(prompt, max_new_tokens=150, temperature=0.7, top_p=0.9):
    # Costruisci input nel formato usato in training
    formatted_prompt = f"<|user|> {prompt.strip()} <|assistant|>"

    # Tokenizza
    inputs = tokenizer(formatted_prompt, return_tensors="pt")

    # Genera risposta
    with torch.no_grad():
        output = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            temperature=temperature,
            top_p=top_p,
            do_sample=True,
            pad_token_id=tokenizer.pad_token_id or tokenizer.eos_token_id
        )

    # Decodifica e rimuovi prompt iniziale
    generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
    response = generated_text.split("<|assistant|>")[-1].strip()
    return response

# 3. Esempio d’uso
if __name__ == "__main__":
    while True:
        user_input = input("👤 Utente: ")
        if user_input.lower() in ["exit", "quit"]:
            break
        response = chat_inference(user_input)
        print(f"🤖 Assistant: {response}\n")

Referenze

• Dataset: Mattimax/DATA-AI_Conversation_ITA
• Modello di base: DACMini
• Organizzazione: M.INC
• Collezione: Little_DAC Collection

Citazione

Se utilizzi Mattimax/DACMini-IT in un progetto, un articolo o qualsiasi lavoro, ti chiediamo gentilmente di citarlo usando il file CITATION.bib incluso nel repository:

@misc{mattimax2025dacminiit,
    title = {{Mattimax/DACMini-IT}: Un modello di linguaggio open source},
    author = {Mattimax},
    howpublished = {\url{https://huggingface.co/Mattimax/DACMini-IT}},
    year = {2025},
    note = {License: MIT. Se usi questo modello, per favore citane la fonte originale.}
}

---

English version

Description

DACMini-IT is a compact, instruction-tuned language model for Italian chat and dialogue. Based on the GPT-2 Small (Italian adaptation) architecture, it is designed to be fast, lightweight, and easily deployable on low-resource devices.

Compared to the “base” DACMini, DACMini-IT is trained on Italian conversational datasets structured in user-assistant format, optimizing its ability to follow instructions and handle natural multi-turn conversations.

---

Size and technical specs

• Parameters: 109M
• Architecture: GPT-2 Small (Italian adaptation)
• Max context length: 512 tokens
• Number of layers: 12
• Number of attention heads: 12
• Embedding size: 768
• Vocabulary: ~50,000 tokens
• Quantization: supported (optional 8-bit / 4-bit via bitsandbytes)

---

Training dataset

Trained on Mattimax/DATA-AI_Conversation_ITA, an Italian instruction-tuned conversational dataset containing structured prompt-response pairs designed to promote coherent, natural, and grammatically correct answers.

---

Objectives

• Italian-language chatbot with instruction-following capabilities.
• Concise, clear, and natural responses in multi-turn contexts.
• Lightweight or offline applications where model size is a constraint.

---

Warnings and limitations

• Experimental model: may produce logical errors or irrelevant answers.
• Not trained on sensitive topics or specialized content.
• Limited performance on very long conversations or complex prompts.
• Not intended for commercial use without further validation.

---

Recommended use

• Lightweight or offline Italian chatbot applications.
• Prototyping and testing of Italian NLP pipelines.
• Synthetic response generation and datasets for training or evaluation.

---

Example inference code

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 1. Load trained model and tokenizer
model_path = "Mattimax/DACMini-IT"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path)
model.eval()

# 2. Generation function
def chat_inference(prompt, max_new_tokens=150, temperature=0.7, top_p=0.9):
    # Build input in the format used during training
    formatted_prompt = f"<|user|> {prompt.strip()} <|assistant|>"

    # Tokenize
    inputs = tokenizer(formatted_prompt, return_tensors="pt")

    # Generate response
    with torch.no_grad():
        output = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            temperature=temperature,
            top_p=top_p,
            do_sample=True,
            pad_token_id=tokenizer.pad_token_id or tokenizer.eos_token_id
        )

    # Decode and remove initial prompt
    generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
    response = generated_text.split("<|assistant|>")[-1].strip()
    return response

# 3. Usage example
if __name__ == "__main__":
    while True:
        user_input = input("👤 User: ")
        if user_input.lower() in ["exit", "quit"]:
            break
        response = chat_inference(user_input)
        print(f"🤖 Assistant: {response}\n")

---

References

• Dataset: Mattimax/DATA-AI_Conversation_ITA
• Base model: DACMini
• Organization: M.INC
• Collection: Little_DAC Collection

---

Citation

If you use Mattimax/DACMini-IT in a project, paper, or any work, please cite it using the CITATION.bib file included in the repository:

@misc{mattimax2025dacminiit,
    title = {{Mattimax/DACMini-IT}: An open-source language model},
    author = {Mattimax},
    howpublished = {\url{https://huggingface.co/Mattimax/DACMini-IT}},
    year = {2025},
    note = {License: MIT. If you use this model, please cite the original source.}
}