Upload appV2.py

appV2.py

@@ -0,0 +1,730 @@
+import numpy as np
+import random
+import requests
+from bs4 import BeautifulSoup
+import re
+import json
+import gradio as gr
+import networkx as nx
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import io
+import time
+from PIL import Image  # Added for image handling
+import asyncio
+import aiohttp
+from tqdm import tqdm  # For progress visualization
+
+# Helper functions for serialization
+def convert_ndarray_to_list(obj):
+    """
+    Recursively convert all ndarray objects in a nested structure to lists.
+    """
+    if isinstance(obj, dict):
+        return {k: convert_ndarray_to_list(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_ndarray_to_list(item) for item in obj]
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    else:
+        return obj
+
+def convert_list_to_ndarray(obj):
+    """
+    Recursively convert all lists in a nested structure back to ndarrays where appropriate.
+    """
+    if isinstance(obj, dict):
+        return {k: convert_list_to_ndarray(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        # Attempt to convert lists of numbers back to ndarrays
+        try:
+            return np.array(obj)
+        except:
+            return [convert_list_to_ndarray(item) for item in obj]
+    else:
+        return obj
+
+class FractalNeuron:
+    def __init__(self, word, position):
+        """
+        Initialize a neuron with a given word and position in the space.
+        """
+        self.word = word
+        self.position = position
+        self.connections = {}  # Connections to other neurons {word: neuron}
+        self.activation = np.random.uniform(-0.1, 0.1)  # Random initial activation
+        self.bias = np.random.uniform(-0.1, 0.1)        # Random bias
+        self.gradient = 0.0
+        self.weights = {}  # Weights of connections {word: weight}
+        self.time_step = 0.01  # Small step size for Euler's method
+        self.gradients = {}   # Gradients for each connection
+
+    def activate(self, input_signal):
+        """
+        Update the neuron's activation based on the input signal.
+        """
+        # Ensure input_signal is a scalar
+        if isinstance(input_signal, np.ndarray):
+            input_signal = np.mean(input_signal)
+        
+        # Update activation using activation function with bias
+        self.activation = np.tanh(input_signal + self.bias)
+        
+        # Ensure activation remains a scalar float
+        if isinstance(self.activation, np.ndarray):
+            self.activation = float(np.mean(self.activation))
+        
+        # Debugging
+        print(f"Neuron '{self.word}' activation after update: {self.activation}")
+
+    def connect(self, other_neuron, weight):
+        """
+        Establish a connection to another neuron with a specified weight.
+        """
+        self.connections[other_neuron.word] = other_neuron
+        self.weights[other_neuron.word] = weight
+
+
+class AdamOptimizer:
+    def __init__(self, learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8, weight_decay=0.0001):
+        self.lr = learning_rate
+        self.beta1 = beta1
+        self.beta2 = beta2
+        self.epsilon = epsilon
+        self.weight_decay = weight_decay
+        self.m = {}
+        self.v = {}
+        self.t = 0
+
+    def update(self, network):
+        """
+        Update the network's weights using Adam optimization.
+        """
+        self.t += 1
+        for word, neuron in network.neurons.items():
+            for connected_word, weight in neuron.weights.items():
+                grad = neuron.gradients.get(connected_word, 0.0) + self.weight_decay * weight
+                if word not in self.m:
+                    self.m[word] = {}
+                if connected_word not in self.m[word]:
+                    self.m[word][connected_word] = 0.0
+                if word not in self.v:
+                    self.v[word] = {}
+                if connected_word not in self.v[word]:
+                    self.v[word][connected_word] = 0.0
+                # Update biased first moment estimate
+                self.m[word][connected_word] = self.beta1 * self.m[word][connected_word] + (1 - self.beta1) * grad
+                # Update biased second raw moment estimate
+                self.v[word][connected_word] = self.beta2 * self.v[word][connected_word] + (1 - self.beta2) * (grad ** 2)
+                # Compute bias-corrected first moment estimate
+                m_hat = self.m[word][connected_word] / (1 - self.beta1 ** self.t)
+                # Compute bias-corrected second raw moment estimate
+                v_hat = self.v[word][connected_word] / (1 - self.beta2 ** self.t)
+                # Update weights
+                update = self.lr * m_hat / (np.sqrt(v_hat) + self.epsilon)
+                neuron.weights[connected_word] += update
+
+
+class FractalNeuralNetwork:
+    def __init__(self, space_size=10, seed=None):
+        """
+        Initialize the Fractal Neural Network.
+        """
+        self.neurons = {}
+        self.space_size = space_size
+        self.learning_rate = 0.001
+        self.beta1 = 0.9
+        self.beta2 = 0.999
+        self.epsilon = 1e-8
+        self.m = {}  # First moment vector (mean) for Adam optimizer
+        self.v = {}  # Second moment vector (variance) for Adam optimizer
+        self.t = 0   # Timestep for Adam optimizer
+        self.rng = np.random.default_rng(seed)
+        self.optimizer = AdamOptimizer(learning_rate=self.learning_rate, beta1=self.beta1,
+                                       beta2=self.beta2, epsilon=self.epsilon, weight_decay=0.0001)
+
+    def tokenize_text(self, text):
+        # Convert to lowercase and split on whitespace
+        tokens = text.lower().split()
+        # Optional: Remove any remaining punctuation
+        tokens = [token.strip('.,!?:;()[]{}') for token in tokens]
+        # Remove any empty tokens
+        tokens = [token for token in tokens if token]
+        return tokens
+
+    def add_word(self, word):
+        """
+        Add a word as a neuron to the network if it doesn't already exist.
+        """
+        if word not in self.neurons:
+            position = self.rng.random(3) * self.space_size
+            self.neurons[word] = FractalNeuron(word, position)
+            return f"Added word: '{word}'."
+        else:
+            return f"Word '{word}' already exists in the network."
+
+    def connect_words(self, word1, word2):
+        """
+        Connect two words in the network with a randomly initialized weight.
+        """
+        if word1 not in self.neurons:
+            return f"Word '{word1}' does not exist in the network."
+        if word2 not in self.neurons:
+            return f"Word '{word2}' does not exist in the network."
+        weight = self.rng.normal()
+        self.neurons[word1].connect(self.neurons[word2], weight)
+        # Initialize optimizer moments for the new connection
+        if word1 not in self.optimizer.m:
+            self.optimizer.m[word1] = {}
+        if word2 not in self.optimizer.m[word1]:
+            self.optimizer.m[word1][word2] = 0.0
+        if word1 not in self.optimizer.v:
+            self.optimizer.v[word1] = {}
+        if word2 not in self.optimizer.v[word1]:
+            self.optimizer.v[word1][word2] = 0.0
+        return f"Connected '{word1}' to '{word2}' with weight {weight:.4f}."
+
+    async def fetch_wikipedia_content_async(self, session, topic):
+        url = f"https://en.wikipedia.org/wiki/{topic.replace(' ', '_')}"
+        try:
+            async with session.get(url) as response:
+                if response.status == 200:
+                    html = await response.text()
+                    soup = BeautifulSoup(html, 'html.parser')
+                    paragraphs = soup.find_all('p')
+                    content = ' '.join([p.text for p in paragraphs])
+                    return topic, content
+                else:
+                    print(f"Failed to fetch {topic}: Status {response.status}")
+                    return topic, None
+        except Exception as e:
+            print(f"Exception fetching {topic}: {e}")
+            return topic, None
+
+    async def learn_from_wikipedia_async(self, topics, concurrency=5):
+        """
+        Asynchronously learn from Wikipedia articles with controlled concurrency.
+        """
+        async with aiohttp.ClientSession() as session:
+            tasks = []
+            for topic in topics:
+                task = asyncio.ensure_future(self.fetch_wikipedia_content_async(session, topic))
+                tasks.append(task)
+            responses = await asyncio.gather(*tasks)
+            
+            results = []
+            for topic, content in responses:
+                if content:
+                    tokens = self.tokenize_text(content)
+                    for token in tokens:
+                        self.add_word(token)
+                    for i in range(len(tokens) - 1):
+                        self.connect_words(tokens[i], tokens[i + 1])
+                    results.append(f"Learned from Wikipedia article: {topic}")
+                else:
+                    results.append(f"Failed to fetch content for: {topic}")
+            return "\n".join(results)
+
+    def fetch_training_data(self, num_sequences=100, seq_length=5):
+        training_data = []
+        for _ in range(num_sequences):
+            if not self.neurons:
+                break
+            start_word = self.rng.choice(list(self.neurons.keys()))
+            url = f"https://api.datamuse.com/words?rel_trg={start_word}&max={seq_length*2}"
+            try:
+                response = requests.get(url)
+                response.raise_for_status()
+                related_words = response.json()
+                if not related_words:
+                    continue
+                input_sequence = [start_word] + [self.tokenize_text(word['word'])[0] for word in related_words[:seq_length-1]]
+                target_sequence = [min(float(word['score']) / 100000, 1.0) for word in related_words[:seq_length]]
+                if len(input_sequence) == seq_length and len(target_sequence) == seq_length:
+                    training_data.append((input_sequence, target_sequence))
+            except requests.RequestException as e:
+                print(f"Error fetching data for {start_word}: {e}")
+        return training_data
+
+    def backpropagate(self, input_sequence, target_sequence, optimizer, dropout_rate=0.2):
+        """
+        Perform backpropagation to update weights based on the error.
+        """
+        activations = self.forward_pass(input_sequence, dropout_rate)
+        if not activations or not target_sequence:
+            return 0.0  # Skip backpropagation for empty sequences
+
+        # Ensure activations and target_sequence have the same shape
+        min_length = min(len(activations), len(target_sequence))
+        activations = activations[:min_length]
+        target_sequence = target_sequence[:min_length]
+
+        # Debugging: Print activations and target_sequence
+        print(f"Activations: {activations}")
+        print(f"Target Sequence: {target_sequence}")
+
+        try:
+            # Ensure both are flat lists of floats
+            activations = [float(a) for a in activations]
+            target_sequence = [float(t) for t in target_sequence]
+            error = np.array(target_sequence, dtype=float) - np.array(activations, dtype=float)
+        except (ValueError, TypeError) as e:
+            print(f"Error computing error: {e}")
+            print(f"Activations: {activations}")
+            print(f"Target Sequence: {target_sequence}")
+            return 0.0  # Skip this backpropagation step due to data inconsistency
+
+        total_loss = 0.0
+
+        for i, word in enumerate(input_sequence[:min_length]):
+            if word in self.neurons:
+                neuron = self.neurons[word]
+                neuron.gradient = error[i] * (1 - neuron.activation ** 2)
+                for connected_word in neuron.connections:
+                    connected_neuron = self.neurons[connected_word]
+                    gradient = neuron.gradient * connected_neuron.activation
+                    neuron.gradients[connected_word] = gradient
+        # Update weights using the optimizer
+        optimizer.update(self)
+        # Calculate loss
+        loss = np.mean(error ** 2)
+        return loss
+
+    def forward_pass(self, input_sequence, dropout_rate=0.2):
+        """
+        Perform a forward pass through the network with the given input sequence.
+        """
+        activations = []
+        for word in input_sequence:
+            if word in self.neurons:
+                neuron = self.neurons[word]
+                # Calculate input_signal as sum of activations * weights
+                input_signal = 0.0
+                for connected_word in neuron.connections:
+                    connected_neuron = self.neurons[connected_word]
+                    act = connected_neuron.activation
+                    input_signal += act * neuron.weights.get(connected_word, 0)
+                neuron.activate(input_signal)
+                # Apply dropout (during training)
+                if random.random() <  dropout_rate:
+                    neuron.activation = 0.0
+                activations.append(neuron.activation)
+            else:
+                activations.append(0.0)
+        return activations
+
+    def attention(self, query, keys, values):
+        """
+        Compute attention weights and context vector.
+        """
+        attention_weights = np.dot(query, np.array(keys).T)
+        attention_weights = np.exp(attention_weights) / np.sum(np.exp(attention_weights))
+        context = np.dot(attention_weights, values)
+        return context, attention_weights
+
+    def generate_response(self, input_sequence, max_length=20, temperature=0.5):
+        """
+        Generate a response based on the input sequence.
+        """
+        response = []
+        context = self.forward_pass(input_sequence)
+        dropout_rate = 0.0  # No dropout during generation
+
+        for _ in range(max_length):
+            query = np.mean(context) if context else 0.0
+            keys = [n.activation for n in self.neurons.values()]
+            values = [n.position for n in self.neurons.values()]
+
+            if not keys or not values:
+                break  # Prevent errors if there are no neurons
+
+            attended_context, _ = self.attention(query, keys, values)
+
+            # Calculate distances and convert to probabilities
+            distances = [np.linalg.norm(n.position - attended_context) for n in self.neurons.values()]
+            probabilities = np.exp(-np.array(distances) / temperature)
+            probabilities /= np.sum(probabilities)
+
+            # Sample word based on probabilities, avoiding repetition
+            try:
+                next_word = self.rng.choice(list(self.neurons.keys()), p=probabilities)
+            except ValueError as e:
+                print(f"Error in sampling next_word: {e}")
+                return "Unable to generate a response at this time."
+
+            if response and next_word == response[-1]:
+                continue  # Avoid immediate repetition
+
+            response.append(next_word)
+            context = self.forward_pass(response[-3:], dropout_rate=dropout_rate)  # Update context with recent words
+
+            if next_word in ['.', '!', '?']:
+                break
+
+        return ' '.join(response)
+
+    def train_with_api_data(self, num_sequences=100, seq_length=5, epochs=10, batch_size=32, learning_rate=0.001, dropout_rate=0.2, weight_decay=0.0001):
+        """
+        Train the network using data fetched from an API with adjustable parameters.
+        """
+        self.learning_rate = learning_rate  # Update learning rate
+        self.optimizer.lr = learning_rate
+        self.optimizer.weight_decay = weight_decay
+        training_data = self.fetch_training_data(num_sequences, seq_length)
+        if not training_data:
+            return "No training data could be fetched. Please ensure the network has words and the API is accessible."
+        for epoch in range(epochs):
+            total_loss = 0
+            valid_sequences = 0
+            for i in range(0, len(training_data), batch_size):
+                batch = training_data[i:i+batch_size]
+                for input_sequence, target_sequence in batch:
+                    if len(input_sequence) != len(target_sequence):
+                        print(f"Skipping sequence due to length mismatch: {len(input_sequence)} != {len(target_sequence)}")
+                        continue
+                    loss = self.backpropagate(input_sequence, target_sequence, self.optimizer, dropout_rate)
+                    total_loss += loss
+                    valid_sequences += 1
+            average_loss = total_loss / valid_sequences if valid_sequences else 0
+            print(f"Epoch {epoch+1}/{epochs}, Average Loss: {average_loss:.6f}, Valid Sequences: {valid_sequences}")
+        return f"Training completed with {valid_sequences} valid sequences for {epochs} epochs"
+
+    async def initialize_with_wikipedia_topics(self, topics):
+        """
+        Initialize the network with a predefined list of Wikipedia topics.
+        """
+        results = await self.learn_from_wikipedia_async(topics, concurrency=5)
+        return results
+
+    def fetch_wikipedia_content(self, topic):
+        """
+        Fetch content from a Wikipedia article based on the topic.
+        """
+        url = f"https://en.wikipedia.org/wiki/{topic.replace(' ', '_')}"
+        try:
+            response = requests.get(url)
+            response.raise_for_status()
+            soup = BeautifulSoup(response.content, 'html.parser')
+            paragraphs = soup.find_all('p')
+            content = ' '.join([p.text for p in paragraphs])
+            return content
+        except requests.RequestException as e:
+            print(f"Error fetching {topic}: {e}")
+            return None
+
+    def learn_from_wikipedia(self, topic):
+        """
+        Learn from a Wikipedia article by tokenizing and adding tokens to the network.
+        """
+        content = self.fetch_wikipedia_content(topic)
+        if content:
+            tokens = self.tokenize_text(content)
+            for token in tokens:
+                self.add_word(token)
+            for i in range(len(tokens) - 1):
+                self.connect_words(tokens[i], tokens[i + 1])
+            return f"Learned from Wikipedia article: {topic}"
+        else:
+            return f"Failed to fetch content for: {topic}"
+
+    def save_state(self, filename):
+        """
+        Save the current state of the network to a JSON file.
+        """
+        state = {
+            'neurons': {
+                word: {
+                    'position': neuron.position.tolist(),
+                    'connections': {w: weight for w, weight in neuron.weights.items()}
+                }
+                for word, neuron in self.neurons.items()
+            },
+            'space_size': self.space_size,
+            'learning_rate': self.learning_rate,
+            'optimizer': {
+                'm': convert_ndarray_to_list(self.optimizer.m),
+                'v': convert_ndarray_to_list(self.optimizer.v),
+                't': self.optimizer.t
+            },
+            'rng_state': convert_ndarray_to_list(self.rng.bit_generator.state)  # Convert ndarrays to lists
+        }
+        try:
+            with open(filename, 'w') as f:
+                json.dump(state, f, indent=4)
+            return f"State saved to {filename}"
+        except Exception as e:
+            return f"Failed to save state to {filename}: {e}"
+
+    @staticmethod
+    def load_state(filename):
+        """
+        Load the network state from a JSON file.
+        """
+        try:
+            with open(filename, 'r') as f:
+                state = json.load(f)
+            network = FractalNeuralNetwork(state['space_size'])
+            network.learning_rate = state['learning_rate']
+            # Restore optimizer state
+            network.optimizer.m = convert_list_to_ndarray(state['optimizer']['m'])
+            network.optimizer.v = convert_list_to_ndarray(state['optimizer']['v'])
+            network.optimizer.t = state['optimizer']['t']
+            # Restore RNG state by converting lists back to ndarrays
+            restored_rng_state = convert_list_to_ndarray(state['rng_state'])
+            network.rng.bit_generator.state = restored_rng_state
+            for word, data in state['neurons'].items():
+                network.add_word(word)
+                network.neurons[word].position = np.array(data['position'])
+                for connected_word, weight in data['connections'].items():
+                    network.connect_words(word, connected_word)
+                    network.neurons[word].weights[connected_word] = weight
+            return network
+        except Exception as e:
+            print(f"Failed to load state from {filename}: {e}")
+            return None
+
+    def visualize(self):
+        """
+        Visualize the network structure using a 3D plot.
+        Returns a PIL Image compatible with Gradio.
+        """
+        if not self.neurons:
+            return "The network is empty. Add words to visualize."
+
+        G = nx.Graph()
+        for word, neuron in self.neurons.items():
+            G.add_node(word, pos=neuron.position)
+        for word, neuron in self.neurons.items():
+            for connected_word in neuron.connections:
+                G.add_edge(word, connected_word)
+
+        fig = plt.figure(figsize=(10, 8))
+        ax = fig.add_subplot(111, projection='3d')
+
+        pos = nx.get_node_attributes(G, 'pos')
+
+        # Extract positions
+        xs = [pos[word][0] for word in G.nodes()]
+        ys = [pos[word][1] for word in G.nodes()]
+        zs = [pos[word][2] for word in G.nodes()]
+
+        # Draw nodes
+        ax.scatter(xs, ys, zs, c='r', s=20)
+
+        # Draw edges
+        for edge in G.edges():
+            x = [pos[edge[0]][0], pos[edge[1]][0]]
+            y = [pos[edge[0]][1], pos[edge[1]][1]]
+            z = [pos[edge[0]][2], pos[edge[1]][2]]
+            ax.plot(x, y, z, c='gray', alpha=0.5)
+
+        ax.set_xlim(0, self.space_size)
+        ax.set_ylim(0, self.space_size)
+        ax.set_zlim(0, self.space_size)
+        plt.title("Fractal Neural Network Visualization")
+
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        plt.close()
+
+        buf.seek(0)
+        image = Image.open(buf)
+        return image
+
+    def chat(self, input_text, temperature=0.5):
+        """
+        Handle chat interactions by generating responses based on input text.
+        """
+        tokens = self.tokenize_text(input_text)
+        if not tokens:
+            return "I didn't understand that. Please try again."
+        response = self.generate_response(tokens, temperature=temperature)
+        # Optionally, train the network with the input and response to improve over time
+        # Here, we train with the input tokens and the response activations
+        response_tokens = self.tokenize_text(response)
+        self.train_with_api_data(
+            num_sequences=1,
+            seq_length=len(tokens),
+            epochs=1,
+            batch_size=1,
+            learning_rate=self.learning_rate
+        )
+        return response
+
+
+def create_gradio_interface():
+    """
+    Create the Gradio interface for interacting with the Fractal Neural Network.
+    """
+    network = FractalNeuralNetwork(seed=42)  # Set a seed for reproducibility
+
+    with gr.Blocks() as iface:
+        gr.Markdown("# 🧠 Fractal Neural Network Interface")
+        gr.Markdown("""
+        **⚠️ Warning:** Training the model with extensive data and high epochs will take a significant amount of time and computational resources. Please ensure your system is equipped to handle the training process.
+        """)
+
+        with gr.Tab("Initialize with Wikipedia Topics"):
+            gr.Markdown("### Initialize the Network with Comprehensive Wikipedia Topics")
+            gr.Markdown("""
+            **Instructions:**
+            - Enter a list of Wikipedia topics separated by commas.
+            - Example topics are pre-filled to guide you.
+            - Click **"Start Initialization"** to begin the process.
+            - **Note:** This may take several minutes depending on the number of topics and your internet connection.
+            """)
+
+            wiki_input = gr.Textbox(
+                label="Wikipedia Topics",
+                placeholder="Enter Wikipedia topics separated by commas...",
+                lines=5,
+                value="Artificial Intelligence, History of Computing, Biology, Physics, Chemistry, Mathematics, World History, Geography, Literature, Philosophy"
+            )
+            init_button = gr.Button("Start Initialization")
+            init_output = gr.Textbox(label="Initialization Output", interactive=False, lines=10)
+
+            async def handle_initialization(wiki_topics):
+                # Split the input string into a list of topics
+                topics = [topic.strip() for topic in wiki_topics.split(",") if topic.strip()]
+                if not topics:
+                    return "Please enter at least one valid Wikipedia topic."
+                # Learn from the provided Wikipedia topics
+                result = await network.initialize_with_wikipedia_topics(topics)
+                # Save the state after initialization
+                save_result = network.save_state("fnn_state.json")
+                return f"{result}\n\n{save_result}"
+
+            init_button.click(fn=handle_initialization, inputs=wiki_input, outputs=init_output)
+
+        with gr.Tab("API Training"):
+            gr.Markdown("### Configure and Start API-Based Training")
+            gr.Markdown("""
+            **Instructions:**
+            - Adjust the training parameters below according to your requirements.
+            - Higher values will result in longer training times and increased computational load.
+            - Click **"Start Training"** to begin the API-based training process.
+            """)
+
+            with gr.Row():
+                num_sequences_input = gr.Number(label="Number of Sequences", value=50000, precision=0, step=1000)
+                seq_length_input = gr.Number(label="Sequence Length", value=15, precision=0, step=1)
+            with gr.Row():
+                epochs_input = gr.Number(label="Number of Epochs", value=100, precision=0, step=1)
+                batch_size_input = gr.Number(label="Batch Size", value=500, precision=0, step=50)
+            with gr.Row():
+                learning_rate_input = gr.Number(label="Learning Rate", value=0.0005, precision=5, step=0.0001)
+            train_button = gr.Button("Start Training")
+            train_output = gr.Textbox(label="Training Output", interactive=False, lines=10)
+
+            def handle_api_training(num_sequences, seq_length, epochs, batch_size, learning_rate):
+                if not network.neurons:
+                    return "The network has no words. Please initialize it with Wikipedia topics first."
+                if num_sequences <= 0 or seq_length <= 0 or epochs <= 0 or batch_size <= 0 or learning_rate <= 0:
+                    return "All training parameters must be positive numbers."
+                # Start training
+                result = network.train_with_api_data(
+                    num_sequences=int(num_sequences),
+                    seq_length=int(seq_length),
+                    epochs=int(epochs),
+                    batch_size=int(batch_size),
+                    learning_rate=float(learning_rate)
+                )
+                # Save the state after training
+                save_result = network.save_state("fnn_state.json")
+                return f"{result}\n\n{save_result}"
+
+            train_button.click(
+                fn=handle_api_training,
+                inputs=[num_sequences_input, seq_length_input, epochs_input, batch_size_input, learning_rate_input],
+                outputs=train_output
+            )
+
+        with gr.Tab("Visualization"):
+            gr.Markdown("### Visualize the Fractal Neural Network")
+            gr.Markdown("""
+            **Instructions:**
+            - Click **"Visualize Network"** to generate a 3D visualization of the network's structure.
+            - Ensure the network has been initialized and trained before visualizing.
+            """)
+
+            visualize_button = gr.Button("Visualize Network")
+            visualize_image = gr.Image(label="Network Visualization")
+
+            def handle_visualize():
+                if not network.neurons:
+                    return "The network is empty. Add words to visualize."
+                return network.visualize()
+
+            visualize_button.click(fn=handle_visualize, inputs=None, outputs=visualize_image)
+
+        with gr.Tab("Chat"):
+            gr.Markdown("### Interact with the Fractal Neural Network")
+            gr.Markdown("""
+            **Instructions:**
+            - Enter your message in the textbox below.
+            - Adjust the **Temperature** slider to control the randomness of the response.
+              - **Lower values (e.g., 0.2):** More deterministic and focused responses.
+              - **Higher values (e.g., 0.8):** More creative and varied responses.
+            - Click **"Chat"** to receive a generated response.
+            """)
+
+            with gr.Row():
+                chat_input = gr.Textbox(label="Your Message", placeholder="Type your message here...", lines=2)
+                chat_temperature = gr.Slider(minimum=0.1, maximum=1.0, value=0.5, step=0.1, label="Temperature")
+            chat_button = gr.Button("Chat")
+            chat_output = gr.Textbox(label="Response", interactive=False, lines=2)
+
+            def handle_chat(input_text, temperature):
+                if not input_text.strip():
+                    return "Please enter a message to chat."
+                response = network.chat(input_text, temperature=temperature)
+                return response
+
+            chat_button.click(fn=handle_chat, inputs=[chat_input, chat_temperature], outputs=chat_output)
+
+        with gr.Tab("State Management"):
+            gr.Markdown("### Save or Load the Network State")
+            gr.Markdown("""
+            **Instructions:**
+            - **Save State:** Enter a filename and click **"Save State"** to save the current network configuration.
+            - **Load State:** Enter a filename and click **"Load State"** to load a previously saved network configuration.
+            - Ensure that the filenames are correctly specified and that the files exist when loading.
+            """)
+
+            with gr.Row():
+                save_filename_input = gr.Textbox(label="Filename to Save State", value="fnn_state.json", placeholder="e.g., fnn_state.json")
+                save_button = gr.Button("Save State")
+            save_output = gr.Textbox(label="Save Output", interactive=False, lines=2)
+
+            def handle_save(filename):
+                if not filename.strip():
+                    return "Please enter a valid filename."
+                result = network.save_state(filename)
+                return result
+
+            save_button.click(fn=handle_save, inputs=save_filename_input, outputs=save_output)
+
+            with gr.Row():
+                load_filename_input = gr.Textbox(label="Filename to Load State", value="fnn_state.json", placeholder="e.g., fnn_state.json")
+                load_button = gr.Button("Load State")
+            load_output = gr.Textbox(label="Load Output", interactive=False, lines=2)
+
+            def handle_load(filename):
+                if not filename.strip():
+                    return "Please enter a valid filename."
+                loaded_network = FractalNeuralNetwork.load_state(filename)
+                if loaded_network:
+                    nonlocal network
+                    network = loaded_network
+                    return f"Loaded state from {filename}."
+                else:
+                    return f"Failed to load state from {filename}."
+
+            load_button.click(fn=handle_load, inputs=load_filename_input, outputs=load_output)
+
+    return iface
+
+
+if __name__ == "__main__":
+    iface = create_gradio_interface()
+    iface.launch()