Update train.py

train.py

@@ -1,4 +1,4 @@
-"""Training - MODIFIED with conversation data"""
+"""Training for Veda Programming Assistant"""
 
 import tensorflow as tf
 from tensorflow import keras
@@ -10,21 +10,21 @@ from model import VedaProgrammingLLM
 from tokenizer import VedaTokenizer
 from config import MODEL_DIR, VOCAB_SIZE, MAX_LENGTH, BATCH_SIZE
 
-# ADDED: Conversation training data
+
 TRAINING_DATA = '''
 <USER> Hello!
-<ASSISTANT> Hello! Welcome to Veda Programming Assistant! I'm here to help you with coding, explain concepts, or answer any programming questions. What would you like to learn today?
+<ASSISTANT> Hello! Welcome to Veda Programming Assistant! I can help you with coding, explain concepts, or answer programming questions. What would you like to learn today?
 
 <USER> What is Python?
-<ASSISTANT> Python is a high-level, interpreted programming language created by Guido van Rossum in 1991. It's known for its simple, readable syntax that emphasizes code readability.
+<ASSISTANT> Python is a high-level, interpreted programming language created by Guido van Rossum in 1991. It is known for its simple, readable syntax.
 
 Key features:
 - Easy to learn and read
 - Dynamic typing
 - Large standard library
-- Great for beginners and experts alike
+- Great for beginners and experts
 
-Python is used for web development, data science, AI, automation, and much more!
+Python is used for web development, data science, AI, automation, and more!
 
 <USER> How do I print hello world?
 <ASSISTANT> To print "Hello, World!" in Python, use the print() function:
@@ -35,10 +35,8 @@ print("Hello, World!")
 
 When you run this, it displays: Hello, World!
 
-The print() function outputs text to the console. You can print strings, numbers, and variables!
-
 <USER> Write a function to add two numbers
-<ASSISTANT> Here's a simple function to add two numbers:
+<ASSISTANT> Here is a simple function to add two numbers:
 
 <CODE>
 def add(a, b):
@@ -52,9 +50,9 @@ print(result)  # Output: 8
 This function takes two parameters and returns their sum.
 
 <USER> Explain what a function is
-<ASSISTANT> A function is a reusable block of code that performs a specific task. Functions help organize code, avoid repetition, and make programs easier to understand.
+<ASSISTANT> A function is a reusable block of code that performs a specific task. Functions help organize code and avoid repetition.
 
-Here's the basic structure:
+Here is the basic structure:
 
 <CODE>
 def function_name(parameters):
@@ -99,23 +97,23 @@ Common operations:
 fruits = ["apple", "banana"]
 
 # Add items
-fruits.append("cherry")     # Add to end
-fruits.insert(0, "apricot") # Insert at position
+fruits.append("cherry")
+fruits.insert(0, "apricot")
 
 # Access items
 print(fruits[0])   # First item
 print(fruits[-1])  # Last item
 
 # Remove items
-fruits.remove("banana")  # Remove by value
-fruits.pop()             # Remove last item
+fruits.remove("banana")
+fruits.pop()
 
 # Length
 print(len(fruits))
 <ENDCODE>
 
 <USER> Write a fibonacci function
-<ASSISTANT> Here's a Fibonacci function with two approaches:
+<ASSISTANT> Here is a Fibonacci function:
 
 Recursive approach:
 
@@ -148,10 +146,8 @@ def fibonacci_iterative(n):
     return b
 <ENDCODE>
 
-The Fibonacci sequence: each number is the sum of the two before it!
-
 <USER> What is recursion?
-<ASSISTANT> Recursion is when a function calls itself to solve a problem. It breaks complex problems into smaller, similar sub-problems.
+<ASSISTANT> Recursion is when a function calls itself to solve a problem.
 
 Key components:
 1. Base case - stops the recursion
@@ -182,10 +178,8 @@ def factorial(n):
 print(factorial(5))  # Output: 120
 <ENDCODE>
 
-Warning: Always have a base case to avoid infinite recursion!
-
 <USER> Write bubble sort
-<ASSISTANT> Here's the Bubble Sort algorithm:
+<ASSISTANT> Here is the Bubble Sort algorithm:
 
 <CODE>
 def bubble_sort(arr):
@@ -214,12 +208,8 @@ Output:
 Original: [64, 34, 25, 12, 22, 11, 90]
 Sorted: [11, 12, 22, 25, 34, 64, 90]
 
-How it works: repeatedly compares adjacent elements and swaps them if in wrong order. Largest elements "bubble up" to the end.
-
-Time complexity: O(n²)
-
 <USER> Write binary search
-<ASSISTANT> Here's the Binary Search algorithm:
+<ASSISTANT> Here is the Binary Search algorithm:
 
 <CODE>
 def binary_search(arr, target):
@@ -245,14 +235,11 @@ print(binary_search(numbers, 6))   # Output: -1
 <ENDCODE>
 
 Important: The array must be sorted!
-
-Time complexity: O(log n) - much faster than linear search!
+Time complexity: O(log n)
 
 <USER> What is a class?
 <ASSISTANT> A class is a blueprint for creating objects. It bundles data (attributes) and functions (methods) together.
 
-Basic class structure:
-
 <CODE>
 class Dog:
     def __init__(self, name, age):
@@ -278,9 +265,7 @@ Key concepts:
 - Methods: functions inside the class
 
 <USER> How do I read a file?
-<ASSISTANT> Here's how to read files in Python:
-
-Basic file reading:
+<ASSISTANT> Here is how to read files in Python:
 
 <CODE>
 # Read entire file
@@ -312,13 +297,9 @@ def read_file_safely(filename):
 content = read_file_safely("myfile.txt")
 <ENDCODE>
 
-The 'with' statement automatically closes the file when done - always recommended!
-
 <USER> How do I handle errors?
 <ASSISTANT> Python uses try-except blocks for error handling:
 
-Basic try-except:
-
 <CODE>
 try:
     result = 10 / 0
@@ -333,7 +314,7 @@ try:
     number = int(input("Enter number: "))
     result = 10 / number
 except ValueError:
-    print("That's not a valid number!")
+    print("Not a valid number!")
 except ZeroDivisionError:
     print("Cannot divide by zero!")
 except Exception as e:
@@ -348,258 +329,183 @@ try:
 except SomeError:
     print("Handle error")
 else:
-    print("Success!")  # Runs if no error
+    print("Success!")
 finally:
-    print("Always runs")  # Cleanup code
+    print("Always runs")
 <ENDCODE>
 
-Common exceptions:
-- ValueError: wrong value
-- TypeError: wrong type
-- IndexError: index out of range
-- KeyError: dictionary key not found
-- FileNotFoundError: file doesn't exist
-
 <USER> Thanks!
-<ASSISTANT> You're welcome! I'm glad I could help. Remember:
-
-- Practice coding every day
-- Build small projects
-- Don't fear errors - they help you learn
-- Ask questions whenever stuck
-
-Feel free to ask me anything anytime! Happy coding! 🐍
-
-<USER> debug this: def add(a b): return a + b
-<ASSISTANT> I found the issue! You're missing a comma between parameters.
-
-Your code:
-```python
-def add(a b): return a + b  # ❌ Missing commaFixed code:
-
-<CODE> def add(a, b): return a + b <ENDCODE>
-The fix: Add a comma between a and b in the parameters.
+<ASSISTANT> You are welcome! I am glad I could help. Feel free to ask me anything anytime! Happy coding!
 
-Testing it:
-
-<CODE> def add(a, b): return a + b
-print(add(5, 3)) # Output: 8
-print(add(10, 20)) # Output: 30
-<ENDCODE>
-
-Common syntax errors to watch:
-
-Missing commas between parameters
-Missing colons after def, if, for, while
-Incorrect indentation
-Mismatched parentheses
 <USER> What is the difference between list and tuple?
 <ASSISTANT> The main difference is mutability:
+- Lists are mutable (can be changed)
+- Tuples are immutable (cannot be changed)
 
-Lists are mutable (can be changed)
-Tuples are immutable (cannot be changed)
 Syntax:
 
-<CODE> # List - square brackets my_list = [1, 2, 3]
-Tuple - parentheses
+<CODE>
+# List - square brackets
+my_list = [1, 2, 3]
+
+# Tuple - parentheses
 my_tuple = (1, 2, 3)
 <ENDCODE>
 
 Mutability difference:
 
-<CODE> # Lists can be modified my_list = [1, 2, 3] my_list[0] = 100 # OK my_list.append(4) # OK
-Tuples cannot be modified
-my_tuple = (1, 2, 3)
+<CODE>
+# Lists can be modified
+my_list = [1, 2, 3]
+my_list[0] = 100     # OK
+my_list.append(4)    # OK
 
-my_tuple[0] = 100 # ERROR!
-my_tuple.append(4) # ERROR!
+# Tuples cannot be modified
+my_tuple = (1, 2, 3)
+# my_tuple[0] = 100  # ERROR!
 <ENDCODE>
-When to use:
 
-List: data that will change (shopping cart, scores)
-Tuple: fixed data (coordinates, RGB colors)
-Example:
+When to use:
+- List: data that will change
+- Tuple: fixed data like coordinates
 
-<CODE> # Tuple for fixed data coordinates = (10, 20) rgb_color = (255, 128, 0)
-List for changing data
-shopping_cart = ["apple", "bread"]
-shopping_cart.append("milk")
-<ENDCODE>
+<USER> Hi
+<ASSISTANT> Hello! How can I help you today? I can write code, explain concepts, or answer your programming questions!
+'''
 
-Other differences:
 
-Tuples are slightly faster
-Tuples use less memory
-Tuples can be dictionary keys
-'''
 class VedaTrainer:
-"""Trainer for Veda Programming Assistant"""def __init__(self, vocab_size: int = 8000, max_length: int = 512, batch_size: int = 4):
-    self.vocab_size = vocab_size
-    self.max_length = max_length
-    self.batch_size = batch_size
-    self.tokenizer = VedaTokenizer(vocab_size=vocab_size)
-    self.model = None
-
-def prepare_data(self, extra_data: str = ""):
-    """Prepare training data"""
-    # Combine training data
-    data = TRAINING_DATA
-    if extra_data:
-        data += "\n\n" + extra_data
-    
-    # Load additional code from programming.txt if exists
-    if os.path.exists("programming.txt"):
-        with open("programming.txt", 'r', encoding='utf-8') as f:
-            code_data = f.read()
-        data += "\n\n" + code_data
-    
-    # Fit tokenizer
-    self.tokenizer.fit([data])
-    
-    # Encode
-    all_tokens = self.tokenizer.encode(data)
-    print(f"Total tokens: {len(all_tokens)}")
-    
-    # Create sequences
-    sequences = []
-    stride = self.max_length // 2
-    
-    for i in range(0, len(all_tokens) - self.max_length - 1, stride):
-        seq = all_tokens[i:i + self.max_length + 1]
-        if len(seq) == self.max_length + 1:
-            sequences.append(seq)
-    
-    if len(sequences) < 10:
-        stride = self.max_length // 4
+    """Trainer for Veda Programming Assistant"""
+    
+    def __init__(self, vocab_size: int = 8000, max_length: int = 512, batch_size: int = 4):
+        self.vocab_size = vocab_size
+        self.max_length = max_length
+        self.batch_size = batch_size
+        self.tokenizer = VedaTokenizer(vocab_size=vocab_size)
+        self.model = None
+    
+    def prepare_data(self, extra_data: str = ""):
+        """Prepare training data"""
+        data = TRAINING_DATA
+        if extra_data:
+            data += "\n\n" + extra_data
+        
+        if os.path.exists("programming.txt"):
+            with open("programming.txt", 'r', encoding='utf-8') as f:
+                code_data = f.read()
+            data += "\n\n" + code_data
+        
+        self.tokenizer.fit([data])
+        
+        all_tokens = self.tokenizer.encode(data)
+        print(f"Total tokens: {len(all_tokens)}")
+        
         sequences = []
+        stride = self.max_length // 2
+        
         for i in range(0, len(all_tokens) - self.max_length - 1, stride):
             seq = all_tokens[i:i + self.max_length + 1]
             if len(seq) == self.max_length + 1:
                 sequences.append(seq)
+        
+        if len(sequences) < 10:
+            stride = self.max_length // 4
+            sequences = []
+            for i in range(0, len(all_tokens) - self.max_length - 1, stride):
+                seq = all_tokens[i:i + self.max_length + 1]
+                if len(seq) == self.max_length + 1:
+                    sequences.append(seq)
+        
+        print(f"Created {len(sequences)} training sequences")
+        
+        sequences = np.array(sequences)
+        X = sequences[:, :-1]
+        y = sequences[:, 1:]
+        
+        dataset = tf.data.Dataset.from_tensor_slices((X, y))
+        dataset = dataset.shuffle(1000).batch(self.batch_size).prefetch(1)
+        
+        return dataset
+    
+    def build_model(self):
+        """Build the model"""
+        self.model = VedaProgrammingLLM(
+            vocab_size=self.tokenizer.vocabulary_size,
+            max_length=self.max_length,
+            d_model=256,
+            num_heads=8,
+            num_layers=4,
+            ff_dim=512
+        )
+        
+        self.model.compile(
+            optimizer=keras.optimizers.Adam(1e-4),
+            loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
+            metrics=['accuracy']
+        )
+        
+        dummy = tf.zeros((1, self.max_length), dtype=tf.int32)
+        self.model(dummy)
+        
+        return self.model
     
-    print(f"Created {len(sequences)} training sequences")
-    
-    sequences = np.array(sequences)
-    X = sequences[:, :-1]
-    y = sequences[:, 1:]
-    
-    dataset = tf.data.Dataset.from_tensor_slices((X, y))
-    dataset = dataset.shuffle(1000).batch(self.batch_size).prefetch(1)
-    
-    return dataset
-
-def build_model(self):
-    """Build the model"""
-    self.model = VedaProgrammingLLM(
-        vocab_size=self.tokenizer.vocabulary_size,
-        max_length=self.max_length,
-        d_model=256,
-        num_heads=8,
-        num_layers=4,
-        ff_dim=512
-    )
-    
-    self.model.compile(
-        optimizer=keras.optimizers.Adam(1e-4),
-        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
-        metrics=['accuracy']
-    )
-    
-    dummy = tf.zeros((1, self.max_length), dtype=tf.int32)
-    self.model(dummy)
+    def train(self, epochs: int = 15, save_path: str = None, extra_data: str = ""):
+        """Train the model"""
+        if save_path is None:
+            save_path = MODEL_DIR
+        
+        dataset = self.prepare_data(extra_data)
+        self.build_model()
+        
+        self.model.summary()
+        
+        os.makedirs(save_path, exist_ok=True)
+        
+        history = self.model.fit(dataset, epochs=epochs, verbose=1)
+        
+        self.model.save_weights(os.path.join(save_path, "weights.h5"))
+        self.tokenizer.save(os.path.join(save_path, "tokenizer.json"))
+        
+        config = self.model.get_config()
+        with open(os.path.join(save_path, "config.json"), 'w') as f:
+            json.dump(config, f)
+        
+        print(f"Model saved to {save_path}")
+        return history
     
-    return self.model
+    def generate_response(self, user_input: str, max_tokens: int = 200, temperature: float = 0.7) -> str:
+        """Generate a response"""
+        prompt = f"<USER> {user_input}\n<ASSISTANT>"
+        
+        tokens = self.tokenizer.encode(prompt)
+        
+        generated = self.model.generate(
+            tokens,
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            repetition_penalty=1.2
+        )
+        
+        response = self.tokenizer.decode(generated)
+        
+        if "<ASSISTANT>" in response:
+            response = response.split("<ASSISTANT>")[-1].strip()
+        if "<USER>" in response:
+            response = response.split("<USER>")[0].strip()
+        
+        return response
 
-def train(self, epochs: int = 15, save_path: str = None, extra_data: str = ""):
-    """Train the model"""
-    if save_path is None:
-        save_path = MODEL_DIR
-    
-    dataset = self.prepare_data(extra_data)
-    self.build_model()
-    
-    self.model.summary()
-    
-    os.makedirs(save_path, exist_ok=True)
-    
-    history = self.model.fit(dataset, epochs=epochs, verbose=1)
-    
-    # Save
-    self.model.save_weights(os.path.join(save_path, "weights.h5"))
-    self.tokenizer.save(os.path.join(save_path, "tokenizer.json"))
-    
-    config = self.model.get_config()
-    with open(os.path.join(save_path, "config.json"), 'w') as f:
-        json.dump(config, f)
-    
-    print(f"Model saved to {save_path}")
-    return history
 
-def generate_response(self, user_input: str, max_tokens: int = 200,
-                     temperature: float = 0.7) -> str:
-    """Generate a response"""
-    prompt = f"<USER> {user_input}\n<ASSISTANT>"
-    
-    tokens = self.tokenizer.encode(prompt)
-    
-    generated = self.model.generate(
-        tokens,
-        max_new_tokens=max_tokens,
-        temperature=temperature,
-        repetition_penalty=1.2
-    )
+if __name__ == "__main__":
+    trainer = VedaTrainer()
+    trainer.train(epochs=20)
     
-    response = self.tokenizer.decode(generated)
+    print("\n" + "="*50)
+    print("Testing:")
+    print("="*50)
     
-    # Extract assistant response
-    if "<ASSISTANT>" in response:
-        response = response.split("<ASSISTANT>")[-1].strip()
-    if "<USER>" in response:
-        response = response.split("<USER>")[0].strip()
+    tests = ["Hello!", "What is a function?", "Write a function to reverse a string"]
     
-    return responseif name == "main":
-trainer = VedaTrainer()
-trainer.train(epochs=20)# Test
-print("\n" + "="*50)
-print("Testing:")
-print("="*50)
-
-tests = [
-    "Hello!",
-    "What is a function?",
-    "Write a function to reverse a string",
-]
-
-for test in tests:
-    print(f"\nUser: {test}")
-    print(f"Assistant: {trainer.generate_response(test)}")
----
-
-### 3. config.py (MODIFY - Increase max_length)
-
-```python
-"""Configuration - MODIFIED for conversation"""
-
-import os
-
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-DATA_DIR = os.path.join(BASE_DIR, "data")
-MODEL_DIR = os.path.join(BASE_DIR, "veda_model")
-
-os.makedirs(DATA_DIR, exist_ok=True)
-os.makedirs(MODEL_DIR, exist_ok=True)
-
-DATABASE_PATH = os.path.join(DATA_DIR, "conversations.db")
-
-# Model settings - MODIFIED
-VOCAB_SIZE = 8000       # Increased for more words
-MAX_LENGTH = 512        # Increased for longer conversations
-D_MODEL = 256
-NUM_HEADS = 8
-NUM_LAYERS = 4
-FF_DIM = 512
-BATCH_SIZE = 4          # Smaller for longer sequences
-
-# Generation defaults
-DEFAULT_TEMPERATURE = 0.7
-DEFAULT_MAX_TOKENS = 200
+    for test in tests:
+        print(f"\nUser: {test}")
+        print(f"Assistant: {trainer.generate_response(test)}")