README.md

---
datasets:
- TeichAI/gpt-5.1-codex-max-1000x
- TeichAI/gpt-5.1-high-reasoning-1000x
base_model:
- openai-community/gpt2-medium
---

Below is a standalone Python GUI application that loads the gss1147/GPT5.1-high-reasoning-codex-0.4B model from Hugging Face and provides a simple interface for text generation. The GUI is built with tkinter and uses transformers and torch for model inference. Generation runs in a separate thread to keep the interface responsive.

Features

· Load the model once at startup.
· Input text box for user prompts.
· Adjustable generation parameters: max new tokens, temperature, top‑p, and repetition penalty.
· Generate button with a progress indicator (text changes to "Generating..." while busy).
· Output displayed in a scrollable text area.
· Error handling for missing dependencies and CUDA issues.

Requirements

Install the required packages before running the script:

```bash
pip install transformers torch
```

(If you have a GPU, ensure you install the appropriate version of PyTorch with CUDA support. The script will automatically use GPU if available.)

The Code

```python
import tkinter as tk
from tkinter import scrolledtext, messagebox, ttk
import threading
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# Model name
MODEL_NAME = "gss1147/GPT5.1-high-reasoning-codex-0.4B"

# Global variables for model and tokenizer (loaded once)
model = None
tokenizer = None

def load_model():
    """Load the model and tokenizer from Hugging Face."""
    global model, tokenizer
    try:
        # Show loading message in the GUI (if root already exists)
        if 'root' in globals():
            status_label.config(text="Loading model... This may take a while.")
            root.update()

        device = "cuda" if torch.cuda.is_available() else "cpu"
        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
        model = AutoModelForCausalLM.from_pretrained(
            MODEL_NAME,
            torch_dtype=torch.float16 if device == "cuda" else torch.float32,
            device_map="auto" if device == "cuda" else None
        )
        if device == "cpu":
            model.to(device)
        model.eval()

        if 'root' in globals():
            status_label.config(text="Model loaded. Ready.")
            generate_button.config(state=tk.NORMAL)
    except Exception as e:
        messagebox.showerror("Error", f"Failed to load model:\n{e}")
        if 'root' in globals():
            status_label.config(text="Loading failed.")
        raise

def generate_text():
    """Start generation in a separate thread."""
    thread = threading.Thread(target=generate_thread)
    thread.start()

def generate_thread():
    """Run generation and update the GUI when done."""
    # Disable the generate button and show progress
    generate_button.config(state=tk.DISABLED, text="Generating...")
    status_label.config(text="Generating...")
    root.update()

    try:
        # Get parameters from the GUI
        prompt = input_text.get("1.0", tk.END).strip()
        if not prompt:
            messagebox.showwarning("Warning", "Please enter a prompt.")
            return

        max_new = int(max_new_tokens_var.get())
        temp = float(temperature_var.get())
        top_p_val = float(top_p_var.get())
        rep_penalty = float(rep_penalty_var.get())

        # Tokenize input
        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

        # Generate
        with torch.no_grad():
            outputs = model.generate(
                **inputs,
                max_new_tokens=max_new,
                temperature=temp,
                top_p=top_p_val,
                repetition_penalty=rep_penalty,
                do_sample=True,
                pad_token_id=tokenizer.eos_token_id
            )

        # Decode and display
        generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
        # Remove the input prompt from the output if desired
        if generated.startswith(prompt):
            generated = generated[len(prompt):].lstrip()

        # Update output in GUI (thread-safe via after)
        root.after(0, lambda: display_output(generated))

    except Exception as e:
        root.after(0, lambda: messagebox.showerror("Error", f"Generation failed:\n{e}"))
    finally:
        # Re-enable button and reset status
        root.after(0, lambda: generate_button.config(state=tk.NORMAL, text="Generate"))
        root.after(0, lambda: status_label.config(text="Ready."))

def display_output(text):
    """Insert generated text into the output box."""
    output_text.delete("1.0", tk.END)
    output_text.insert(tk.END, text)

# ------------------- GUI Setup -------------------
root = tk.Tk()
root.title("GPT-5.1 0.4B Text Generator")
root.geometry("800x700")
root.resizable(True, True)

# Style
root.option_add("*Font", "Arial 11")

# Status bar at the top
status_label = tk.Label(root, text="Initializing...", bd=1, relief=tk.SUNKEN, anchor=tk.W)
status_label.pack(fill=tk.X, padx=5, pady=2)

# Main frame
main_frame = ttk.Frame(root, padding="10")
main_frame.pack(fill=tk.BOTH, expand=True)

# Input label and text area
ttk.Label(main_frame, text="Input Prompt:").grid(row=0, column=0, sticky=tk.W, pady=5)
input_text = scrolledtext.ScrolledText(main_frame, height=8, wrap=tk.WORD)
input_text.grid(row=1, column=0, columnspan=3, sticky=(tk.W, tk.E, tk.N, tk.S), pady=5)

# Generation parameters
param_frame = ttk.LabelFrame(main_frame, text="Generation Parameters", padding="10")
param_frame.grid(row=2, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=10)

# Max new tokens
ttk.Label(param_frame, text="Max New Tokens:").grid(row=0, column=0, sticky=tk.W, padx=5)
max_new_tokens_var = tk.StringVar(value="100")
ttk.Entry(param_frame, textvariable=max_new_tokens_var, width=8).grid(row=0, column=1, sticky=tk.W)

# Temperature
ttk.Label(param_frame, text="Temperature:").grid(row=0, column=2, sticky=tk.W, padx=5)
temperature_var = tk.StringVar(value="0.7")
ttk.Entry(param_frame, textvariable=temperature_var, width=8).grid(row=0, column=3, sticky=tk.W)

# Top-p
ttk.Label(param_frame, text="Top-p:").grid(row=1, column=0, sticky=tk.W, padx=5)
top_p_var = tk.StringVar(value="0.9")
ttk.Entry(param_frame, textvariable=top_p_var, width=8).grid(row=1, column=1, sticky=tk.W)

# Repetition penalty
ttk.Label(param_frame, text="Rep. Penalty:").grid(row=1, column=2, sticky=tk.W, padx=5)
rep_penalty_var = tk.StringVar(value="1.1")
ttk.Entry(param_frame, textvariable=rep_penalty_var, width=8).grid(row=1, column=3, sticky=tk.W)

# Generate button
generate_button = ttk.Button(main_frame, text="Generate", command=generate_text, state=tk.DISABLED)
generate_button.grid(row=3, column=0, pady=10)

# Output label and text area
ttk.Label(main_frame, text="Generated Output:").grid(row=4, column=0, sticky=tk.W, pady=5)
output_text = scrolledtext.ScrolledText(main_frame, height=15, wrap=tk.WORD)
output_text.grid(row=5, column=0, columnspan=3, sticky=(tk.W, tk.E, tk.N, tk.S), pady=5)

# Configure grid weights so text areas expand
main_frame.columnconfigure(0, weight=1)
main_frame.rowconfigure(1, weight=1)
main_frame.rowconfigure(5, weight=1)

# Start loading the model in the background after GUI is up
root.after(100, lambda: threading.Thread(target=load_model, daemon=True).start())

root.mainloop()
```

How to Use

1. Save the code as gpt_gui.py.
2. Install the dependencies: pip install transformers torch.
3. Run the script: python gpt_gui.py.
4. Wait for the model to load (a status bar shows progress).
5. Enter a prompt, adjust parameters if needed, and click Generate.
6. The generated text appears in the lower box.

Notes

· The model is about 0.4 B parameters, so it requires roughly 1–2 GB of RAM/VRAM.
· If you have a GPU with sufficient memory, the script will automatically use it (via device_map="auto").
· Generation can take a few seconds to tens of seconds depending on your hardware and the number of tokens requested.
· The GUI remains responsive during generation because the work is done in a separate thread.

Enjoy experimenting with the model!