First_Persian_SLM_Big_Update_Version3_ysnrfd

7

2

1 language

—

by

ysn-rfd

Language Model

OTHER

New

7 downloads

Early-stage

Try on Hugging Face Add to Compare

Edge AI:

Mobile

Laptop

Server

Unknown

Mobile

Laptop

Server

Quick Summary

WARNINNGS: This Model IS Pre-Trained, in the future will be finetuned.

Code Examples

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Model Architecture and Objectivepythontransformers

import torch
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import re


model_path = "./Path_To_Model"
print(f"{model_path}...")

tokenizer = GPT2Tokenizer.from_pretrained(model_path)
model = GPT2LMHeadModel.from_pretrained(model_path)


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"{device}")
model.to(device)
model.eval()  


try:
    end_token_id = tokenizer.convert_tokens_to_ids("### End")
    if end_token_id == tokenizer.unk_token_id:
        end_token_id = None
except:
    end_token_id = None

print("\n------+------+------+------ model is ready for testing +------+------++------\n")
print("type exit for exit")
print("\nYSNRFD")
print("------+------+------+----------------------+------+------++------\n")


while True:
   
    user_input = input("\nYou: ").strip()
    
    
    if user_input.lower() in ["exit"]:
        print("\n good bye (ysnrfd)")
        break
    
    
    prompt = f"### Human: {user_input}\n### Assistant:"
    
   
    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=512
    ).to(device)
    
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=400,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=end_token_id or tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
    
   
    assistant_response = full_response[len(prompt):].strip()
    
    
    if "### End" in assistant_response:
        assistant_response = assistant_response.split("### End")[0].strip()
    
    
    assistant_response = re.sub(r'^###\s*Assistant:\s*', '', assistant_response)
    
    
    if assistant_response:
        print(f"\nBot: {assistant_response}")
    else:
        print("\nBot: please again say")

Deploy This Model

Production-ready deployment in minutes

Together.ai

Instant API access to this model

Fastest API

Production-ready inference API. Start free, scale to millions.

Replicate

One-click model deployment

Easiest Setup

Run models in the cloud with simple API. No DevOps required.

Disclosure: We may earn a commission from these partners. This helps keep LLMYourWay free.