LFM2 2.6B Uncensored X64

Name: LFM2 2.6B Uncensored X64
Author: sirev

2.6B

—

sirev

Language Model

OTHER

2.6B params

New

43 downloads

Early-stage

Try on Hugging Face Add to Compare

Edge AI:

Mobile

Laptop

Server

6GB+ RAM

Mobile

Laptop

Server

Quick Summary

This model is uncensored version of LiquidAI/LFM-2-2.

Device Compatibility

Mobile

4-6GB RAM

Laptop

16GB RAM

Server

GPU

Minimum Recommended

3GB+ RAM

Code Examples

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

pythontransformers

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

id = "sirev/LFM2-2.6B-Uncensored-X64"

tokenizer = AutoTokenizer.from_pretrained(id)

model = AutoModelForCausalLM.from_pretrained(id).to(device)

messages = [
    {"role": "user", "content": "Your message here..."}
]
user = messages[0]['content']

inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True,
        return_dict=True,
        return_tensors="pt",
).to(device)

print(f"User: {user}")

outputs = model.generate(**inputs, temperature=0.3, do_sample=True, repetition_penalty=1.2, max_new_tokens=2048)

print(f"AI: {tokenizer.decode(outputs[0][inputs['input_ids'].shape[-1]:], skip_special_tokens=True)}")

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.

Try Free API

Replicate

One-click model deployment

Easiest Setup

Run models in the cloud with simple API. No DevOps required.

Deploy Now

Disclosure: We may earn a commission from these partners. This helps keep LLMYourWay free.