Instructions to use nickprock/Gemma3-1B-CulturaViva-ITA with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use nickprock/Gemma3-1B-CulturaViva-ITA with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="nickprock/Gemma3-1B-CulturaViva-ITA")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("nickprock/Gemma3-1B-CulturaViva-ITA")
model = AutoModelForCausalLM.from_pretrained("nickprock/Gemma3-1B-CulturaViva-ITA")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use nickprock/Gemma3-1B-CulturaViva-ITA with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "nickprock/Gemma3-1B-CulturaViva-ITA"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "nickprock/Gemma3-1B-CulturaViva-ITA",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/nickprock/Gemma3-1B-CulturaViva-ITA

SGLang

How to use nickprock/Gemma3-1B-CulturaViva-ITA with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "nickprock/Gemma3-1B-CulturaViva-ITA" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "nickprock/Gemma3-1B-CulturaViva-ITA",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "nickprock/Gemma3-1B-CulturaViva-ITA" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "nickprock/Gemma3-1B-CulturaViva-ITA",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use nickprock/Gemma3-1B-CulturaViva-ITA with Docker Model Runner:
```
docker model run hf.co/nickprock/Gemma3-1B-CulturaViva-ITA
```

🇮🇹 Gemma3-1B-CulturaViva-ITA

Gemma3-1B-CulturaViva-ITA è un modello linguistico basato sull'architettura Gemma 3 (1B parametri), sottoposto a fine-tuning per specializzarsi nella comprensione e generazione di testi relativi alla cultura, storia e tradizioni italiane.

Questo modello è stato addestrato per rispondere in italiano in modo accurato e contestualizzato, superando le barriere linguistiche e culturali dei modelli base generalisti. I pesi LoRA sono già stati uniti al modello base, rendendolo un modello standalone pronto all'uso.

🛠️ Dettagli del Modello

Modello Base: Gemma 3 (1B Instruct)
Lingua: Italiano (it)
Metodo di Addestramento: QLoRA (Quantized Low-Rank Adaptation) -> Merged
Versione GGUF (Quantizzata): nickprock/Gemma3-1B-CulturaViva-ITA-Q4_K_M-GGUF
Framework: PyTorch, Hugging Face transformers, peft, trl
Autore: nickprock

🎯 Uso Previsto (Intended Use)

Il modello è ideale per:

Assistenti virtuali specializzati in turismo e cultura italiana.
Generazione di contenuti (articoli, riassunti, guide) su storia, arte e tradizioni del Bel Paese.
Q&A (Domande e Risposte) su contesti storici e culturali italiani.

🦙 Come usare il modello in locale con Ollama (GGUF)

Il metodo più veloce per provare il modello sul tuo PC, sfruttando la versione quantizzata a 4-bit (leggerissima ed efficiente), è utilizzare Ollama.

Metodo 1: Avvio Rapido (Consigliato)

Apri il tuo terminale e lancia questo comando. Ollama scaricherà automaticamente il modello da Hugging Face e avvierà la chat:

ollama run hf.co/nickprock/Gemma3-1B-CulturaViva-ITA-Q4_K_M-GGUF

Metodo 2: Configurazione Avanzata (Modelfile)

Se vuoi personalizzare il comportamento del modello (ad esempio, dandogli un ruolo specifico o cambiando la creatività), crea un file di testo chiamato Modelfile sul tuo PC e inserisci questo codice:

# Usa direttamente il repository di Hugging Face!
FROM hf.co/nickprock/Gemma3-1B-CulturaViva-ITA-Q4_K_M-GGUF

# Imposta i parametri di generazione
PARAMETER temperature 0.7
PARAMETER num_ctx 4096

# Imposta un system prompt per dare contesto al modello
SYSTEM """Sei un assistente virtuale esperto di cultura, storia e tradizioni italiane. Rispondi alle domande in italiano in modo chiaro, accurato e appassionato."""

Apri il terminale nella stessa cartella del file e lancia:

# Crea il tuo assistente personalizzato
ollama create CulturaViva -f Modelfile

# Avvia la chat!
ollama run CulturaViva

🚀 Come usare il modello (Python / Hugging Face)

Per gli sviluppatori che desiderano integrare il modello base a 16-bit nei loro script Python:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "nickprock/Gemma3-1B-CulturaViva-ITA"

# 1. Carica Tokenizer e Modello
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 2. Prepara il prompt utilizzando il chat template
messages = [
    {"role": "user", "content": "Parlami dell'importanza del Rinascimento italiano nell'arte."}
]
prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

# 3. Genera la risposta
outputs = model.generate(**inputs, max_new_tokens=300, temperature=0.7)

# 4. Decodifica e stampa solo la risposta generata
input_length = inputs["input_ids"].shape[1]
response = tokenizer.decode(outputs[0][input_length:], skip_special_tokens=True)
print(response)

⚙️ Dettagli del Training (Dietro le quinte)

Il processo di fine-tuning è stato un percorso di ottimizzazione intensivo, calibrato per estrarre le massime performance dall'hardware limitando il consumo di VRAM.

Iperparametri e Configurazione (LoRA)

Metodo: LoRA standard caricato in BFLOAT16 per massimizzare la velocità sulle architetture GPU di ultima generazione (Ada Lovelace / Blackwell), con successiva fusione dei pesi (merge_and_unload).
LoRA Rank (r): 16
LoRA Alpha: 16 (Valore conservativo per garantire stabilità e non sovrascrivere eccessivamente i pesi base)
Target Modules: all-linear
LoRA Dropout: 0.05
Task Type: CAUSAL_LM
Precisione: bfloat16 nativo.
Ottimizzazione Memoria: Batch size reale espanso tramite Gradient Accumulation (16 steps) mantenendo un per_device_batch_size di 1, combinato con Gradient Checkpointing per azzerare il VRAM thrashing e mantenere i consumi sotto gli 8 GB di VRAM dedicata.

Risultati del Training

Il modello ha completato un'epoca intera elaborando oltre 26,4 milioni di token. La curva di apprendimento si è rivelata estremamente sana, mostrando una totale assenza di Overfitting. La Validation Loss ha seguito in parallelo la Training Loss fino alla fine, confermando una straordinaria capacità di generalizzazione del modello sui dati non visti. L'accuratezza media sui token ha superato il 70%.

Evoluzione delle Metriche (Campionamento sull'Epoca):