Small-lamina-pretrain

56

1

1 language

—

by

Clemylia

Language Model

OTHER

New

56 downloads

Early-stage

Try on Hugging Face Add to Compare

Edge AI:

Mobile

Laptop

Server

Unknown

Mobile

Laptop

Server

Quick Summary

📖 Documentation Officielle : Small-Lamina-Pretrain (51M) Bienvenue dans l'univers de Lamina \!

Code Examples

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Code PyTorch pour la Génération (Inférence)pythontransformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. Définir le Modèle et l'Appareil
MODEL_REPO = "Clemylia/Small-lamina-pretrain"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # Utilise ta carte graphique (CUDA) si possible, sinon le CPU

# 2. Charger le Tokenizer et le Modèle
tokenizer = AutoTokenizer.from_pretrained(MODEL_REPO)
model = AutoModelForCausalLM.from_pretrained(MODEL_REPO).to(DEVICE)

print(f"Modèle Lamina chargé sur {DEVICE} et prêt à générer ! 💡")

# 3. Fonction de Génération
def generer_lamina(prompt, max_tokens=50):
    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
    
    # Paramètres de Génération pour la créativité (Lamining !)
    # do_sample=True et top_p/top_k contrôlent l'originalité des réponses.
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        do_sample=True,
        top_k=50,
        top_p=0.95,
        pad_token_id=tokenizer.eos_token_id
    )
    
    output = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
    return output

# 4. Tester ton Lamina !
mon_prompt = "Je crois que la capitale de la France est"
resultat = generer_lamina(mon_prompt)

print("\n--- Résultat du Lamina ---")
print(resultat)

Deploy This Model

Production-ready deployment in minutes

Together.ai

Instant API access to this model

Fastest API

Production-ready inference API. Start free, scale to millions.

Replicate

One-click model deployment

Easiest Setup

Run models in the cloud with simple API. No DevOps required.

Disclosure: We may earn a commission from these partners. This helps keep LLMYourWay free.