Update train.py

train.py

@@ -375,4 +375,231 @@ Feel free to ask me anything anytime! Happy coding! 🐍
 
 Your code:
 ```python
-def add(a b): return a + b  # ❌ Missing comma
+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.
+
+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)
+Syntax:
+
+<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)
+
+my_tuple[0] = 100 # ERROR!
+my_tuple.append(4) # ERROR!
+<ENDCODE>
+When to use:
+
+List: data that will change (shopping cart, scores)
+Tuple: fixed data (coordinates, RGB colors)
+Example:
+
+<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>
+
+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
+        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
+
+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
+    )
+    
+    response = self.tokenizer.decode(generated)
+    
+    # Extract assistant response
+    if "<ASSISTANT>" in response:
+        response = response.split("<ASSISTANT>")[-1].strip()
+    if "<USER>" in response:
+        response = response.split("<USER>")[0].strip()
+    
+    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