Create app.py

app.py

@@ -0,0 +1,127 @@
+# app.py
+import gradio as gr
+import tensorflow as tf
+import pickle
+import numpy as np
+import os
+
+# --- 1. CONFIGURATION & MODEL LOADING ---
+# This section loads your trained AI models and the tokenizers needed to understand text.
+MAX_SEQ_LENGTH = 30 # Must match the value used during training!
+
+print("Loading models and tokenizers...")
+try:
+    # Load the "Go Larger" model and its vocabulary
+    successor_model = tf.keras.models.load_model('successor_model.h5')
+    with open('successor_model_tokenizers.pkl', 'rb') as f:
+        successor_tokenizers = pickle.load(f)
+    
+    # Load the "Go Smaller" model and its vocabulary
+    predecessor_model = tf.keras.models.load_model('predecessor_model.h5')
+    with open('predecessor_model_tokenizers.pkl', 'rb') as f:
+        predecessor_tokenizers = pickle.load(f)
+
+    print("Models and tokenizers loaded successfully.")
+except Exception as e:
+    # This helps debug issues on Hugging Face Spaces if a file is missing
+    print(f"FATAL ERROR loading files: {e}")
+    successor_model, predecessor_model = None, None
+
+# --- 2. THE CORE PREDICTION LOGIC ---
+# This function is the "brain" of the application.
+def predict_next_state(direction, current_unit, current_analogy, current_commentary):
+    # Safety check in case models failed to load
+    if not all([successor_model, predecessor_model]):
+        return "Error: Models are not loaded.", "Please check the server logs on Hugging Face.", "---"
+
+    # A. Select the correct AI model and tokenizers based on user's click
+    model = successor_model if direction == "larger" else predecessor_model
+    tokenizers = successor_tokenizers if direction == "larger" else predecessor_tokenizers
+    
+    # B. Prepare the input data for the model
+    # The input text must be converted to numbers exactly as it was during training.
+    input_data = {
+        'current_unit_name': [current_unit],
+        'current_analogy': [current_analogy],
+        'current_commentary': [current_commentary]
+    }
+    
+    processed_input = {}
+    for col, text_list in input_data.items():
+        sequences = tokenizers[col].texts_to_sequences(text_list)
+        padded_sequences = tf.keras.preprocessing.sequence.pad_sequences(sequences, maxlen=MAX_SEQ_LENGTH, padding='post')
+        processed_input[col] = padded_sequences
+        
+    # C. Get the AI's prediction
+    predictions = model.predict(processed_input)
+    
+    # D. Decode the prediction from numbers back to human-readable text
+    target_texts = {}
+    output_cols = ['target_unit_name', 'target_analogy', 'target_commentary']
+    
+    for i, col in enumerate(output_cols):
+        # The model outputs probabilities; we take the most likely token (word) at each step.
+        pred_indices = np.argmax(predictions[i], axis=-1)
+        # Use the tokenizer to convert the sequence of indices back into a sentence.
+        predicted_sequence = tokenizers[col].sequences_to_texts(pred_indices)[0]
+        # Clean up padding and unknown words
+        target_texts[col] = predicted_sequence.replace('<oov>', '').replace(' end', '').strip()
+    
+    # E. Handle the "Infinity" Sentinel
+    # Check if the AI returned our special signal.
+    if "end of knowledge" in target_texts['target_unit_name'].lower():
+        # If so, switch to the simple rule-based procedural engine.
+        prefix = "Giga-" if direction == "larger" else "pico-"
+        new_unit = f"{prefix}{current_unit}"
+        new_analogy = "A procedurally generated unit beyond the AI's known universe."
+        new_commentary = "This represents a step into true infinity, where rules replace learned knowledge."
+        return new_unit, new_analogy, new_commentary
+    else:
+        # Otherwise, return the AI's generated response.
+        return target_texts['target_unit_name'], target_texts['target_analogy'], target_texts['target_commentary']
+
+# Wrapper functions for the buttons
+def go_larger(unit, analogy, commentary):
+    return predict_next_state("larger", unit, analogy, commentary)
+
+def go_smaller(unit, analogy, commentary):
+    return predict_next_state("smaller", unit, analogy, commentary)
+
+# --- 3. THE GRADIO USER INTERFACE ---
+# This section defines the layout and interactivity of the web page.
+initial_unit = "Byte"
+initial_analogy = "A single character of text, like 'R'"
+initial_commentary = "From binary choices, a building block is formed, ready to hold a single, recognizable symbol."
+
+# Use gr.Blocks for a custom layout
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="sky")) as demo:
+    gr.Markdown("# 🤖 Digital Scale Explorer AI")
+    gr.Markdown("An AI trained from scratch to explore the infinite ladder of data sizes. Click the buttons to traverse the universe of data!")
+    
+    with gr.Row():
+        # Define the output text boxes
+        unit_name_out = gr.Textbox(value=initial_unit, label="Unit Name", interactive=False, elem_id="unit_name_style")
+        analogy_out = gr.Textbox(value=initial_analogy, label="Analogy", lines=4, interactive=False, elem_id="analogy_style")
+        commentary_out = gr.Textbox(value=initial_commentary, label="AI Commentary", lines=3, interactive=False, elem_id="commentary_style")
+
+    with gr.Row():
+        # Define the buttons
+        smaller_btn = gr.Button("Go Smaller ⬇️", variant="secondary", size="lg")
+        larger_btn = gr.Button("Go Larger ⬆️", variant="primary", size="lg")
+    
+    # Connect the "Go Larger" button to its function
+    larger_btn.click(
+        fn=go_larger,
+        inputs=[unit_name_out, analogy_out, commentary_out],
+        outputs=[unit_name_out, analogy_out, commentary_out]
+    )
+    # Connect the "Go Smaller" button to its function
+    smaller_btn.click(
+        fn=go_smaller,
+        inputs=[unit_name_out, analogy_out, commentary_out],
+        outputs=[unit_name_out, analogy_out, commentary_out]
+    )
+
+# Launch the app when the script is run
+if __name__ == "__main__":
+    demo.launch()