Update app.py

app.py

@@ -5,20 +5,21 @@ import base64
 import streamlit as st
 import pandas as pd
 import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
 from torch.utils.data import Dataset, DataLoader
 import csv
 import time
 from dataclasses import dataclass
-from typing import Optional
+from typing import Optional, Tuple
 import zipfile
 import math
 from PIL import Image
 import random
 import logging
 import numpy as np
-import cv2
-from diffusers import DiffusionPipeline
+from diffusers import StableDiffusionPipeline, DDPMPipeline, EulerAncestralDiscreteScheduler
 
+# Logging setup with a custom buffer
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 log_records = []
@@ -29,6 +30,7 @@ class LogCaptureHandler(logging.Handler):
 
 logger.addHandler(LogCaptureHandler())
 
+# Page Configuration
 st.set_page_config(
     page_title="SFT Tiny Titans 🚀",
     page_icon="🤖",
@@ -37,22 +39,32 @@ st.set_page_config(
     menu_items={
         'Get Help': 'https://huggingface.co/awacke1',
         'Report a Bug': 'https://huggingface.co/spaces/awacke1',
-        'About': "Tiny Titans: Small diffusion models, big CV dreams! 🌌"
+        'About': "Tiny Titans: Small models, big dreams, and a sprinkle of chaos! 🌌"
     }
 )
 
+# Initialize st.session_state
 if 'captured_images' not in st.session_state:
     st.session_state['captured_images'] = []
-if 'cv_builder' not in st.session_state:
-    st.session_state['cv_builder'] = None
-if 'cv_loaded' not in st.session_state:
-    st.session_state['cv_loaded'] = False
-if 'active_tab' not in st.session_state:
-    st.session_state['active_tab'] = "Build Titan 🌱"
+if 'builder' not in st.session_state:
+    st.session_state['builder'] = None
+if 'model_loaded' not in st.session_state:
+    st.session_state['model_loaded'] = False
+
+# Model Configuration Classes
+@dataclass
+class ModelConfig:
+    name: str
+    base_model: str
+    size: str
+    domain: Optional[str] = None
+    model_type: str = "causal_lm"
+    @property
+    def model_path(self):
+        return f"models/{self.name}"
 
 @dataclass
 class DiffusionConfig:
-    """Config for our diffusion heroes 🦸‍♂️ - Keeps the blueprint snappy!"""
     name: str
     base_model: str
     size: str
@@ -60,8 +72,29 @@ class DiffusionConfig:
     def model_path(self):
         return f"diffusion_models/{self.name}"
 
+# Datasets
+class SFTDataset(Dataset):
+    def __init__(self, data, tokenizer, max_length=128):
+        self.data = data
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+    def __len__(self):
+        return len(self.data)
+    def __getitem__(self, idx):
+        prompt = self.data[idx]["prompt"]
+        response = self.data[idx]["response"]
+        full_text = f"{prompt} {response}"
+        full_encoding = self.tokenizer(full_text, max_length=self.max_length, padding="max_length", truncation=True, return_tensors="pt")
+        prompt_encoding = self.tokenizer(prompt, max_length=self.max_length, padding=False, truncation=True, return_tensors="pt")
+        input_ids = full_encoding["input_ids"].squeeze()
+        attention_mask = full_encoding["attention_mask"].squeeze()
+        labels = input_ids.clone()
+        prompt_len = prompt_encoding["input_ids"].shape[1]
+        if prompt_len < self.max_length:
+            labels[:prompt_len] = -100
+        return {"input_ids": input_ids, "attention_mask": attention_mask, "labels": labels}
+
 class DiffusionDataset(Dataset):
-    """Pixel party platter 🍕 - Images and text for diffusion delight!"""
     def __init__(self, images, texts):
         self.images = images
         self.texts = texts
@@ -70,591 +103,417 @@ class DiffusionDataset(Dataset):
     def __getitem__(self, idx):
         return {"image": self.images[idx], "text": self.texts[idx]}
 
-class MicroDiffusionBuilder:
-    """Tiny titan of diffusion 🐣 - Small but mighty for quick demos!"""
+# Model Builders
+class ModelBuilder:
     def __init__(self):
         self.config = None
-        self.pipeline = None
-        self.jokes = ["Micro but mighty! 💪", "Small pixels, big dreams! 🌟"]
-    def load_model(self, model_path: str, config: Optional[DiffusionConfig] = None):
-        try:
-            with st.spinner(f"Loading {model_path}... ⏳ (Tiny titan powering up!)"):
-                self.pipeline = DiffusionPipeline.from_pretrained(model_path, low_cpu_mem_usage=True)
-                self.pipeline.to("cuda" if torch.cuda.is_available() else "cpu")
-                if config:
-                    self.config = config
-            st.success(f"Model loaded! 🎉 {random.choice(self.jokes)}")
-            logger.info(f"Loaded Micro Diffusion: {model_path}")
-        except Exception as e:
-            st.error(f"Failed to load {model_path}: {str(e)} 💥 (Tiny titan tripped!)")
-            logger.error(f"Failed to load {model_path}: {str(e)}")
-            raise
+        self.model = None
+        self.tokenizer = None
+        self.sft_data = None
+        self.jokes = ["Why did the AI go to therapy? Too many layers to unpack! 😂", "Training complete! Time for a binary coffee break. ☕"]
+    def load_model(self, model_path: str, config: Optional[ModelConfig] = None):
+        with st.spinner(f"Loading {model_path}... ⏳"):
+            self.model = AutoModelForCausalLM.from_pretrained(model_path)
+            self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            if config:
+                self.config = config
+            self.model.to("cuda" if torch.cuda.is_available() else "cpu")
+        st.success(f"Model loaded! 🎉 {random.choice(self.jokes)}")
         return self
-    def fine_tune_sft(self, images, texts, epochs=3):
-        try:
-            dataset = DiffusionDataset(images, texts)
-            dataloader = DataLoader(dataset, batch_size=1, shuffle=True)
-            optimizer = torch.optim.AdamW(self.pipeline.unet.parameters(), lr=1e-5)
-            self.pipeline.unet.train()
-            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            for epoch in range(epochs):
-                with st.spinner(f"Epoch {epoch + 1}/{epochs}... ⚙️ (Micro titan flexing!)"):
-                    total_loss = 0
-                    for batch in dataloader:
-                        optimizer.zero_grad()
-                        image = batch["image"][0].to(device)
-                        text = batch["text"][0]
-                        latents = self.pipeline.vae.encode(torch.tensor(np.array(image)).permute(2, 0, 1).unsqueeze(0).float().to(device)).latent_dist.sample()
-                        noise = torch.randn_like(latents)
-                        timesteps = torch.randint(0, self.pipeline.scheduler.num_train_timesteps, (latents.shape[0],), device=latents.device)
-                        noisy_latents = self.pipeline.scheduler.add_noise(latents, noise, timesteps)
-                        text_embeddings = self.pipeline.text_encoder(self.pipeline.tokenizer(text, return_tensors="pt").input_ids.to(device))[0]
-                        pred_noise = self.pipeline.unet(noisy_latents, timesteps, encoder_hidden_states=text_embeddings).sample
-                        loss = torch.nn.functional.mse_loss(pred_noise, noise)
-                        loss.backward()
-                        optimizer.step()
-                        total_loss += loss.item()
-                    st.write(f"Epoch {epoch + 1} done! Loss: {total_loss / len(dataloader):.4f}")
-            st.success(f"Micro Diffusion tuned! 🎉 {random.choice(self.jokes)}")
-            logger.info(f"Fine-tuned Micro Diffusion: {self.config.name}")
-        except Exception as e:
-            st.error(f"Tuning failed: {str(e)} 💥 (Micro snag!)")
-            logger.error(f"Tuning failed: {str(e)}")
-            raise
+    def fine_tune_sft(self, csv_path: str, epochs: int = 3, batch_size: int = 4):
+        self.sft_data = []
+        with open(csv_path, "r") as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                self.sft_data.append({"prompt": row["prompt"], "response": row["response"]})
+        dataset = SFTDataset(self.sft_data, self.tokenizer)
+        dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+        optimizer = torch.optim.AdamW(self.model.parameters(), lr=2e-5)
+        self.model.train()
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model.to(device)
+        for epoch in range(epochs):
+            with st.spinner(f"Training epoch {epoch + 1}/{epochs}... ⚙️"):
+                total_loss = 0
+                for batch in dataloader:
+                    optimizer.zero_grad()
+                    input_ids = batch["input_ids"].to(device)
+                    attention_mask = batch["attention_mask"].to(device)
+                    labels = batch["labels"].to(device)
+                    outputs = self.model(input_ids=input_ids, attention_mask=attention_mask, labels=labels)
+                    loss = outputs.loss
+                    loss.backward()
+                    optimizer.step()
+                    total_loss += loss.item()
+                st.write(f"Epoch {epoch + 1} completed. Average loss: {total_loss / len(dataloader):.4f}")
+        st.success(f"SFT Fine-tuning completed! 🎉 {random.choice(self.jokes)}")
         return self
     def save_model(self, path: str):
+        with st.spinner("Saving model... 💾"):
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            self.model.save_pretrained(path)
+            self.tokenizer.save_pretrained(path)
+        st.success(f"Model saved at {path}! ✅")
+    def evaluate(self, prompt: str, status_container=None):
+        self.model.eval()
+        if status_container:
+            status_container.write("Preparing to evaluate... 🧠")
         try:
-            with st.spinner("Saving model... 💾 (Packing tiny pixels!)"):
-                os.makedirs(os.path.dirname(path), exist_ok=True)
-                self.pipeline.save_pretrained(path)
-            st.success(f"Saved at {path}! ✅ Tiny titan secured!")
-            logger.info(f"Saved at {path}")
-        except Exception as e:
-            st.error(f"Save failed: {str(e)} 💥 (Packing mishap!)")
-            logger.error(f"Save failed: {str(e)}")
-            raise
-    def generate(self, prompt: str):
-        try:
-            return self.pipeline(prompt, num_inference_steps=20).images[0]
+            with torch.no_grad():
+                inputs = self.tokenizer(prompt, return_tensors="pt", max_length=128, truncation=True).to(self.model.device)
+                outputs = self.model.generate(**inputs, max_new_tokens=50, do_sample=True, top_p=0.95, temperature=0.7)
+                return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
         except Exception as e:
-            st.error(f"Generation failed: {str(e)} 💥 (Pixel oopsie!)")
-            logger.error(f"Generation failed: {str(e)}")
-            raise
+            if status_container:
+                status_container.error(f"Oops! Something broke: {str(e)} 💥")
+            return f"Error: {str(e)}"
 
-class LatentDiffusionBuilder:
-    """Scaled-down dreamer 🌙 - Latent magic for efficient artistry!"""
+class DiffusionBuilder:
     def __init__(self):
         self.config = None
         self.pipeline = None
-        self.jokes = ["Latent vibes only! 🌀", "Small scale, big style! 🎨"]
-    def load_model(self, model_path: str, config: Optional[DiffusionConfig] = None):
-        try:
-            with st.spinner(f"Loading {model_path}... ⏳ (Latent titan rising!)"):
-                self.pipeline = DiffusionPipeline.from_pretrained(model_path, low_cpu_mem_usage=True)
-                self.pipeline.unet = torch.nn.Sequential(*list(self.pipeline.unet.children())[:2])  # Scale down U-Net
-                self.pipeline.to("cuda" if torch.cuda.is_available() else "cpu")
-                if config:
-                    self.config = config
-            st.success(f"Model loaded! 🎉 {random.choice(self.jokes)}")
-            logger.info(f"Loaded Latent Diffusion: {model_path}")
-        except Exception as e:
-            st.error(f"Failed to load {model_path}: {str(e)} 💥 (Latent hiccup!)")
-            logger.error(f"Failed to load {model_path}: {str(e)}")
-            raise
+        self.model_type = None
+    def load_model(self, model_path: str, config: Optional[DiffusionConfig] = None, model_type: str = "StableDiffusion"):
+        with st.spinner(f"Loading diffusion model {model_path}... ⏳"):
+            if model_type == "StableDiffusion":
+                self.pipeline = StableDiffusionPipeline.from_pretrained(model_path, torch_dtype=torch.float32).to("cpu")
+            elif model_type == "DDPM":
+                self.pipeline = DDPMPipeline.from_pretrained(model_path, torch_dtype=torch.float32).to("cpu")
+                self.pipeline.scheduler = EulerAncestralDiscreteScheduler.from_config(self.pipeline.scheduler.config)
+            if config:
+                self.config = config
+            self.model_type = model_type
+        st.success(f"Diffusion model loaded! 🎨")
         return self
     def fine_tune_sft(self, images, texts, epochs=3):
-        try:
-            dataset = DiffusionDataset(images, texts)
-            dataloader = DataLoader(dataset, batch_size=1, shuffle=True)
-            optimizer = torch.optim.AdamW(self.pipeline.unet.parameters(), lr=1e-5)
-            self.pipeline.unet.train()
-            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            for epoch in range(epochs):
-                with st.spinner(f"Epoch {epoch + 1}/{epochs}... ⚙️ (Latent titan shaping up!)"):
-                    total_loss = 0
-                    for batch in dataloader:
-                        optimizer.zero_grad()
-                        image = batch["image"][0].to(device)
-                        text = batch["text"][0]
-                        latents = self.pipeline.vae.encode(torch.tensor(np.array(image)).permute(2, 0, 1).unsqueeze(0).float().to(device)).latent_dist.sample()
-                        noise = torch.randn_like(latents)
-                        timesteps = torch.randint(0, self.pipeline.scheduler.num_train_timesteps, (latents.shape[0],), device=latents.device)
-                        noisy_latents = self.pipeline.scheduler.add_noise(latents, noise, timesteps)
-                        text_embeddings = self.pipeline.text_encoder(self.pipeline.tokenizer(text, return_tensors="pt").input_ids.to(device))[0]
-                        pred_noise = self.pipeline.unet(noisy_latents, timesteps, encoder_hidden_states=text_embeddings).sample
-                        loss = torch.nn.functional.mse_loss(pred_noise, noise)
-                        loss.backward()
-                        optimizer.step()
-                        total_loss += loss.item()
-                    st.write(f"Epoch {epoch + 1} done! Loss: {total_loss / len(dataloader):.4f}")
-            st.success(f"Latent Diffusion tuned! 🎉 {random.choice(self.jokes)}")
-            logger.info(f"Fine-tuned Latent Diffusion: {self.config.name}")
-        except Exception as e:
-            st.error(f"Tuning failed: {str(e)} 💥 (Latent snag!)")
-            logger.error(f"Tuning failed: {str(e)}")
-            raise
+        dataset = DiffusionDataset(images, texts)
+        dataloader = DataLoader(dataset, batch_size=1, shuffle=True)
+        optimizer = torch.optim.AdamW(self.pipeline.unet.parameters(), lr=1e-5)
+        self.pipeline.unet.train()
+        for epoch in range(epochs):
+            with st.spinner(f"Training diffusion epoch {epoch + 1}/{epochs}... ⚙️"):
+                total_loss = 0
+                for batch in dataloader:
+                    optimizer.zero_grad()
+                    image = batch["image"][0].to(self.pipeline.device)
+                    text = batch["text"][0]
+                    latents = self.pipeline.vae.encode(torch.tensor(np.array(image)).permute(2, 0, 1).unsqueeze(0).float().to(self.pipeline.device)).latent_dist.sample()
+                    noise = torch.randn_like(latents)
+                    timesteps = torch.randint(0, self.pipeline.scheduler.num_train_timesteps, (latents.shape[0],), device=latents.device)
+                    noisy_latents = self.pipeline.scheduler.add_noise(latents, noise, timesteps)
+                    text_embeddings = self.pipeline.text_encoder(self.pipeline.tokenizer(text, return_tensors="pt").input_ids.to(self.pipeline.device))[0]
+                    pred_noise = self.pipeline.unet(noisy_latents, timesteps, encoder_hidden_states=text_embeddings).sample
+                    loss = torch.nn.functional.mse_loss(pred_noise, noise)
+                    loss.backward()
+                    optimizer.step()
+                    total_loss += loss.item()
+                st.write(f"Epoch {epoch + 1} completed. Average loss: {total_loss / len(dataloader):.4f}")
+        st.success("Diffusion SFT Fine-tuning completed! 🎨")
         return self
     def save_model(self, path: str):
-        try:
-            with st.spinner("Saving model... 💾 (Packing latent dreams!)"):
-                os.makedirs(os.path.dirname(path), exist_ok=True)
-                self.pipeline.save_pretrained(path)
-            st.success(f"Saved at {path}! ✅ Latent titan stashed!")
-            logger.info(f"Saved at {path}")
-        except Exception as e:
-            st.error(f"Save failed: {str(e)} 💥 (Dreamy mishap!)")
-            logger.error(f"Save failed: {str(e)}")
-            raise
-    def generate(self, prompt: str):
-        try:
-            return self.pipeline(prompt, num_inference_steps=30).images[0]
-        except Exception as e:
-            st.error(f"Generation failed: {str(e)} 💥 (Latent oopsie!)")
-            logger.error(f"Generation failed: {str(e)}")
-            raise
-
-class FluxDiffusionBuilder:
-    """Distilled dynamo ⚡ - High-quality pixels in a small package!"""
-    def __init__(self):
-        self.config = None
-        self.pipeline = None
-        self.jokes = ["Flux-tastic! ✨", "Small size, big wow! 🎇"]
-    def load_model(self, model_path: str, config: Optional[DiffusionConfig] = None):
-        try:
-            with st.spinner(f"Loading {model_path}... ⏳ (Flux titan charging!)"):
-                self.pipeline = DiffusionPipeline.from_pretrained(model_path, low_cpu_mem_usage=True)
-                self.pipeline.to("cuda" if torch.cuda.is_available() else "cpu")
-                if config:
-                    self.config = config
-            st.success(f"Model loaded! 🎉 {random.choice(self.jokes)}")
-            logger.info(f"Loaded FLUX.1 Distilled: {model_path}")
-        except Exception as e:
-            st.error(f"Failed to load {model_path}: {str(e)} 💥 (Flux fizzle!)")
-            logger.error(f"Failed to load {model_path}: {str(e)}")
-            raise
-        return self
-    def fine_tune_sft(self, images, texts, epochs=3):
-        try:
-            dataset = DiffusionDataset(images, texts)
-            dataloader = DataLoader(dataset, batch_size=1, shuffle=True)
-            optimizer = torch.optim.AdamW(self.pipeline.unet.parameters(), lr=1e-5)
-            self.pipeline.unet.train()
-            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            for epoch in range(epochs):
-                with st.spinner(f"Epoch {epoch + 1}/{epochs}... ⚙️ (Flux titan powering up!)"):
-                    total_loss = 0
-                    for batch in dataloader:
-                        optimizer.zero_grad()
-                        image = batch["image"][0].to(device)
-                        text = batch["text"][0]
-                        latents = self.pipeline.vae.encode(torch.tensor(np.array(image)).permute(2, 0, 1).unsqueeze(0).float().to(device)).latent_dist.sample()
-                        noise = torch.randn_like(latents)
-                        timesteps = torch.randint(0, self.pipeline.scheduler.num_train_timesteps, (latents.shape[0],), device=latents.device)
-                        noisy_latents = self.pipeline.scheduler.add_noise(latents, noise, timesteps)
-                        text_embeddings = self.pipeline.text_encoder(self.pipeline.tokenizer(text, return_tensors="pt").input_ids.to(device))[0]
-                        pred_noise = self.pipeline.unet(noisy_latents, timesteps, encoder_hidden_states=text_embeddings).sample
-                        loss = torch.nn.functional.mse_loss(pred_noise, noise)
-                        loss.backward()
-                        optimizer.step()
-                        total_loss += loss.item()
-                    st.write(f"Epoch {epoch + 1} done! Loss: {total_loss / len(dataloader):.4f}")
-            st.success(f"FLUX Diffusion tuned! 🎉 {random.choice(self.jokes)}")
-            logger.info(f"Fine-tuned FLUX.1 Distilled: {self.config.name}")
-        except Exception as e:
-            st.error(f"Tuning failed: {str(e)} 💥 (Flux snag!)")
-            logger.error(f"Tuning failed: {str(e)}")
-            raise
-        return self
-    def save_model(self, path: str):
-        try:
-            with st.spinner("Saving model... 💾 (Packing flux magic!)"):
-                os.makedirs(os.path.dirname(path), exist_ok=True)
-                self.pipeline.save_pretrained(path)
-            st.success(f"Saved at {path}! ✅ Flux titan secured!")
-            logger.info(f"Saved at {path}")
-        except Exception as e:
-            st.error(f"Save failed: {str(e)} 💥 (Fluxy mishap!)")
-            logger.error(f"Save failed: {str(e)}")
-            raise
-    def generate(self, prompt: str):
-        try:
+        with st.spinner("Saving diffusion model... 💾"):
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            self.pipeline.save_pretrained(path)
+        st.success(f"Diffusion model saved at {path}! ✅")
+    def generate(self, prompt: str, image=None):
+        if self.model_type == "StableDiffusion":
             return self.pipeline(prompt, num_inference_steps=50).images[0]
-        except Exception as e:
-            st.error(f"Generation failed: {str(e)} 💥 (Flux oopsie!)")
-            logger.error(f"Generation failed: {str(e)}")
-            raise
+        elif self.model_type == "DDPM":
+            return self.pipeline(num_inference_steps=50).images[0]
 
+# Utility Functions
 def generate_filename(sequence, ext="png"):
-    """Time-stamped snapshots ⏰ - Keeps our pics organized with cam flair!"""
     from datetime import datetime
     import pytz
     central = pytz.timezone('US/Central')
-    dt = datetime.now(central)
-    return f"{dt.strftime('%m-%d-%Y-%I-%M-%S-%p')}-{sequence}.{ext}"
+    timestamp = datetime.now(central).strftime("%d%m%Y%H%M%S%p")
+    return f"{sequence}{timestamp}.{ext}"
 
 def get_download_link(file_path, mime_type="text/plain", label="Download"):
-    """Magic link maker 🔗 - Snag your files with a click!"""
-    try:
-        with open(file_path, 'rb') as f:
-            data = f.read()
-        b64 = base64.b64encode(data).decode()
-        return f'<a href="data:{mime_type};base64,{b64}" download="{os.path.basename(file_path)}">{label} 📥</a>'
-    except Exception as e:
-        logger.error(f"Failed to generate link for {file_path}: {str(e)}")
-        return f"Error: Could not generate link for {file_path}"
-
-def zip_files(files, zip_path):
-    """Zip zap zoo 🎒 - Bundle up your goodies!"""
-    try:
-        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+    with open(file_path, 'rb') as f:
+        data = f.read()
+    b64 = base64.b64encode(data).decode()
+    return f'<a href="data:{mime_type};base64,{b64}" download="{os.path.basename(file_path)}">{label} 📥</a>'
+
+def zip_directory(directory_path, zip_path):
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        for root, _, files in os.walk(directory_path):
             for file in files:
-                zipf.write(file, os.path.basename(file))
-        logger.info(f"Created ZIP file: {zip_path}")
-    except Exception as e:
-        logger.error(f"Failed to create ZIP {zip_path}: {str(e)}")
-        raise
-
-def delete_files(files):
-    """Trash titan 🗑️ - Clear the stage for new stars!"""
-    try:
-        for file in files:
-            os.remove(file)
-            logger.info(f"Deleted file: {file}")
-        st.session_state['captured_images'] = [f for f in st.session_state['captured_images'] if f not in files]
-    except Exception as e:
-        logger.error(f"Failed to delete files: {str(e)}")
-        raise
-
-def get_model_files():
-    """Model treasure hunt 🗺️ - Find our diffusion gems!"""
-    return [d for d in glob.glob("diffusion_models/*") if os.path.isdir(d)]
+                zipf.write(os.path.join(root, file), os.path.relpath(os.path.join(root, file), os.path.dirname(directory_path)))
+
+def get_model_files(model_type="causal_lm"):
+    path = "models/*" if model_type == "causal_lm" else "diffusion_models/*"
+    return [d for d in glob.glob(path) if os.path.isdir(d)]
 
 def get_gallery_files(file_types):
-    """Gallery curator 🖼️ - Showcase our pixel masterpieces!"""
-    return sorted(list(set(f for ext in file_types for f in glob.glob(f"*.{ext}"))))
+    return sorted([f for ext in file_types for f in glob.glob(f"*.{ext}")])
 
 def update_gallery():
-    """Gallery refresh 🌟 - Keep the art flowing!"""
     media_files = get_gallery_files(["png"])
     if media_files:
         cols = st.sidebar.columns(2)
         for idx, file in enumerate(media_files[:gallery_size * 2]):
             with cols[idx % 2]:
                 st.image(Image.open(file), caption=file, use_container_width=True)
-                st.markdown(get_download_link(file, "image/png", "Download Snap 📸"), unsafe_allow_html=True)
-
-def get_available_video_devices():
-    """Camera roll call 🎥 - Who’s ready to shine? Fallback if OpenCV flops!"""
-    video_devices = [f"Camera {i} 🎥" for i in range(6)]  # Default to 6 cams
-    try:
-        detected = []
-        for i in range(6):  # Limit to 6 as per your setup
-            cap = cv2.VideoCapture(i, cv2.CAP_V4L2)
-            if not cap.isOpened():
-                cap = cv2.VideoCapture(i)
-            if cap.isOpened():
-                detected.append(f"Camera {i} 🎥")
-                logger.info(f"Detected camera at index {i}")
-                cap.release()
-        if detected:
-            video_devices = detected
-        else:
-            logger.warning("No cameras detected by OpenCV; using defaults")
-    except Exception as e:
-        logger.error(f"Error detecting cameras: {str(e)} - Falling back to defaults")
-    return video_devices
-
-st.title("SFT Tiny Titans 🚀 (Small Diffusion Delight!)")
-
+                st.markdown(get_download_link(file, "image/png", "Download Image"), unsafe_allow_html=True)
+
+# Mock Search Tool for RAG
+def mock_search(query: str) -> str:
+    if "superhero" in query.lower():
+        return "Latest trends: Gold-plated Batman statues, VR superhero battles."
+    return "No relevant results found."
+
+class PartyPlannerAgent:
+    def __init__(self, model, tokenizer):
+        self.model = model
+        self.tokenizer = tokenizer
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model.to(self.device)
+    def generate(self, prompt: str) -> str:
+        self.model.eval()
+        with torch.no_grad():
+            inputs = self.tokenizer(prompt, return_tensors="pt", max_length=128, truncation=True).to(self.device)
+            outputs = self.model.generate(**inputs, max_new_tokens=100, do_sample=True, top_p=0.95, temperature=0.7)
+            return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+    def plan_party(self, task: str) -> pd.DataFrame:
+        search_result = mock_search("superhero party trends")
+        prompt = f"Given this context: '{search_result}'\n{task}"
+        plan_text = self.generate(prompt)
+        locations = {"Wayne Manor": (42.3601, -71.0589), "New York": (40.7128, -74.0060)}
+        wayne_coords = locations["Wayne Manor"]
+        travel_times = {loc: calculate_cargo_travel_time(coords, wayne_coords) for loc, coords in locations.items() if loc != "Wayne Manor"}
+        data = [
+            {"Location": "New York", "Travel Time (hrs)": travel_times["New York"], "Luxury Idea": "Gold-plated Batman statues"},
+            {"Location": "Wayne Manor", "Travel Time (hrs)": 0.0, "Luxury Idea": "VR superhero battles"}
+        ]
+        return pd.DataFrame(data)
+
+class CVPartyPlannerAgent:
+    def __init__(self, pipeline):
+        self.pipeline = pipeline
+    def generate(self, prompt: str) -> Image.Image:
+        return self.pipeline(prompt, num_inference_steps=50).images[0]
+    def plan_party(self, task: str) -> pd.DataFrame:
+        search_result = mock_search("superhero party trends")
+        prompt = f"Given this context: '{search_result}'\n{task}"
+        data = [
+            {"Theme": "Batman", "Image Idea": "Gold-plated Batman statue"},
+            {"Theme": "Avengers", "Image Idea": "VR superhero battle scene"}
+        ]
+        return pd.DataFrame(data)
+
+def calculate_cargo_travel_time(origin_coords: Tuple[float, float], destination_coords: Tuple[float, float], cruising_speed_kmh: float = 750.0) -> float:
+    def to_radians(degrees: float) -> float:
+        return degrees * (math.pi / 180)
+    lat1, lon1 = map(to_radians, origin_coords)
+    lat2, lon2 = map(to_radians, destination_coords)
+    EARTH_RADIUS_KM = 6371.0
+    dlon = lon2 - lon1
+    dlat = lat2 - lat1
+    a = (math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2)
+    c = 2 * math.asin(math.sqrt(a))
+    distance = EARTH_RADIUS_KM * c
+    actual_distance = distance * 1.1
+    flight_time = (actual_distance / cruising_speed_kmh) + 1.0
+    return round(flight_time, 2)
+
+# Main App
+st.title("SFT Tiny Titans 🚀 (Small but Mighty!)")
+
+# Sidebar Galleries
 st.sidebar.header("Media Gallery 🎨")
-gallery_size = st.sidebar.slider("Gallery Size 📸", 1, 10, 4, help="How many snaps to flaunt? 🌟")
+gallery_size = st.sidebar.slider("Gallery Size", 1, 10, 4)
 update_gallery()
 
-col1, col2 = st.sidebar.columns(2)
-with col1:
-    if st.button("Download All 📦"):
-        media_files = get_gallery_files(["png"])
-        if media_files:
-            zip_path = f"snapshot_collection_{int(time.time())}.zip"
-            zip_files(media_files, zip_path)
-            st.sidebar.markdown(get_download_link(zip_path, "application/zip", "Download All Snaps 📦"), unsafe_allow_html=True)
-            st.sidebar.success("Snaps zipped! 🎉 Grab your loot!")
-        else:
-            st.sidebar.warning("No snaps to zip! 📸 Snap some first!")
-with col2:
-    if st.button("Delete All 🗑️"):
-        media_files = get_gallery_files(["png"])
-        if media_files:
-            delete_files(media_files)
-            st.sidebar.success("Snaps vanquished! 🧹 Gallery cleared!")
-            update_gallery()
-        else:
-            st.sidebar.warning("Nothing to delete! 📸 Snap some pics!")
-
-uploaded_files = st.sidebar.file_uploader("Upload Goodies 🎵🎥🖼️📝📜", type=["mp3", "mp4", "png", "jpeg", "md", "pdf", "docx"], accept_multiple_files=True)
-if uploaded_files:
-    for uploaded_file in uploaded_files:
-        filename = uploaded_file.name
-        with open(filename, "wb") as f:
-            f.write(uploaded_file.getvalue())
-        logger.info(f"Uploaded file: {filename}")
-
-st.sidebar.subheader("Image Gallery 🖼️")
-image_files = get_gallery_files(["png", "jpeg"])
-if image_files:
-    cols = st.sidebar.columns(2)
-    for idx, file in enumerate(image_files[:gallery_size * 2]):
-        with cols[idx % 2]:
-            st.image(Image.open(file), caption=file, use_container_width=True)
-            st.markdown(get_download_link(file, "image/png" if file.endswith(".png") else "image/jpeg", f"Save Pic 🖼️"), unsafe_allow_html=True)
-
 st.sidebar.subheader("Model Management 🗂️")
-model_dirs = get_model_files()
+model_type = st.sidebar.selectbox("Model Type", ["Causal LM", "Diffusion"])
+model_dirs = get_model_files("causal_lm" if model_type == "Causal LM" else "diffusion")
 selected_model = st.sidebar.selectbox("Select Saved Model", ["None"] + model_dirs)
-model_type = st.sidebar.selectbox("Diffusion Type", ["Micro Diffusion", "Latent Diffusion", "FLUX.1 Distilled"])
 if selected_model != "None" and st.sidebar.button("Load Model 📂"):
-    builder = {
-        "Micro Diffusion": MicroDiffusionBuilder,
-        "Latent Diffusion": LatentDiffusionBuilder,
-        "FLUX.1 Distilled": FluxDiffusionBuilder
-    }[model_type]()
-    config = DiffusionConfig(name=os.path.basename(selected_model), base_model="unknown", size="small")
-    try:
-        builder.load_model(selected_model, config)
-        st.session_state['cv_builder'] = builder
-        st.session_state['cv_loaded'] = True
-        st.rerun()
-    except Exception as e:
-        st.error(f"Model load failed: {str(e)} 💥 (Check logs for details!)")
-
-st.sidebar.subheader("Model Status 🚦")
-st.sidebar.write(f"**CV Model**: {'Loaded' if st.session_state['cv_loaded'] else 'Not Loaded'} {'(Active)' if st.session_state['cv_loaded'] and isinstance(st.session_state.get('cv_builder'), (MicroDiffusionBuilder, LatentDiffusionBuilder, FluxDiffusionBuilder)) else ''}")
-
-tabs = ["Build Titan 🌱", "Camera Snap 📷", "Fine-Tune Titan (CV) 🔧", "Test Titan (CV) 🧪", "Agentic RAG Party (CV) 🌐"]
-tab1, tab2, tab3, tab4, tab5 = st.tabs(tabs)
+    builder = ModelBuilder() if model_type == "Causal LM" else DiffusionBuilder()
+    config = (ModelConfig if model_type == "Causal LM" else DiffusionConfig)(name=os.path.basename(selected_model), base_model="unknown", size="small")
+    builder.load_model(selected_model, config)
+    st.session_state['builder'] = builder
+    st.session_state['model_loaded'] = True
+    st.rerun()
 
-for i, tab in enumerate(tabs):
-    if st.session_state['active_tab'] != tab and st.session_state.get(f'tab{i}_active', False):
-        logger.info(f"Switched to tab: {tab}")
-        st.session_state['active_tab'] = tab
-    st.session_state[f'tab{i}_active'] = (st.session_state['active_tab'] == tab)
+# Tabs (Reordered: Camera Snap first)
+tab1, tab2, tab3, tab4, tab5 = st.tabs(["Camera Snap 📷", "Fine-Tune Titan 🔧", "Build Titan 🌱", "Test Titan 🧪", "Agentic RAG Party 🌐"])
 
 with tab1:
-    st.header("Build Titan 🌱")
-    model_type = st.selectbox("Diffusion Type", ["Micro Diffusion", "Latent Diffusion", "FLUX.1 Distilled"], key="build_type")
-    base_model = st.selectbox("Select Tiny Model", 
-        ["CompVis/ldm-text2im-large-256" if model_type == "Micro Diffusion" else "runwayml/stable-diffusion-v1-5" if model_type == "Latent Diffusion" else "black-forest-labs/flux.1-distilled"])
-    model_name = st.text_input("Model Name", f"tiny-titan-{int(time.time())}")
-    if st.button("Download Model ⬇️"):
-        config = DiffusionConfig(name=model_name, base_model=base_model, size="small")
-        builder = {
-            "Micro Diffusion": MicroDiffusionBuilder,
-            "Latent Diffusion": LatentDiffusionBuilder,
-            "FLUX.1 Distilled": FluxDiffusionBuilder
-        }[model_type]()
-        try:
-            builder.load_model(base_model, config)
-            builder.save_model(config.model_path)
-            st.session_state['cv_builder'] = builder
-            st.session_state['cv_loaded'] = True
-            st.rerun()
-        except Exception as e:
-            st.error(f"Model build failed: {str(e)} 💥 (Check logs for details!)")
-
-with tab2:
-    st.header("Camera Snap 📷 (Dual Capture Fiesta!)")
-    video_devices = get_available_video_devices()
-    st.write(f"🎉 Detected Cameras: {', '.join(video_devices)}")
-    st.info("Switch cams in your browser settings (e.g., Chrome > Privacy > Camera) since I’m a browser star! 🌟")
-
-    st.subheader("Camera 0 🎬 - Lights, Camera, Action!")
-    cam0_cols = st.columns(4)
-    with cam0_cols[0]:
-        cam0_device = st.selectbox("Cam 📷", video_devices, index=0, key="cam0_device", help="Pick your star cam! 🌟")
-    with cam0_cols[1]:
-        cam0_label = st.text_input("Tag 🏷️", "Cam 0 Snap", key="cam0_label", help="Name your masterpiece! 🎨")
-    with cam0_cols[2]:
-        cam0_help = st.text_input("Hint 💡", "Snap a heroic moment! 🦸‍♂️", key="cam0_help", help="Give a fun tip!")
-    with cam0_cols[3]:
-        cam0_vis = st.selectbox("Show 🖼️", ["visible", "hidden", "collapsed"], index=0, key="cam0_vis", help="Label vibes: Visible, Sneaky, or Gone!")
-
-    st.subheader("Camera 1 🎥 - Roll the Film!")
-    cam1_cols = st.columns(4)
-    with cam1_cols[0]:
-        cam1_device = st.selectbox("Cam 📷", video_devices, index=1 if len(video_devices) > 1 else 0, key="cam1_device", help="Choose your blockbuster cam! 🎬")
-    with cam1_cols[1]:
-        cam1_label = st.text_input("Tag 🏷️", "Cam 1 Snap", key="cam1_label", help="Title your epic shot! 🌠")
-    with cam1_cols[2]:
-        cam1_help = st.text_input("Hint 💡", "Grab an epic frame! 🌟", key="cam1_help", help="Drop a cheeky hint!")
-    with cam1_cols[3]:
-        cam1_vis = st.selectbox("Show 🖼️", ["visible", "hidden", "collapsed"], index=0, key="cam1_vis", help="Label style: Show it, Hide it, Poof!")
-
+    st.header("Camera Snap 📷 (Dual Capture!)")
+    slice_count = st.number_input("Image Slice Count", min_value=1, max_value=20, value=10)
+    video_length = st.number_input("Video Length (seconds)", min_value=1, max_value=30, value=10)
     cols = st.columns(2)
     with cols[0]:
-        st.subheader(f"Camera 0 ({cam0_device}) 🎬")
-        cam0_img = st.camera_input(
-            label=cam0_label,
-            key="cam0",
-            help=cam0_help,
-            disabled=False,
-            label_visibility=cam0_vis
-        )
+        st.subheader("Camera 0")
+        cam0_img = st.camera_input("Take a picture - Cam 0", key="cam0")
         if cam0_img:
-            filename = generate_filename("cam0")
+            filename = generate_filename(0)
             with open(filename, "wb") as f:
                 f.write(cam0_img.getvalue())
             st.image(Image.open(filename), caption=filename, use_container_width=True)
             logger.info(f"Saved snapshot from Camera 0: {filename}")
             st.session_state['captured_images'].append(filename)
             update_gallery()
-        st.info("🚨 One snap at a time—your Titan’s too cool for bursts! 😎")
+        if st.button(f"Capture {slice_count} Frames - Cam 0 📸"):
+            st.session_state['cam0_frames'] = []
+            for i in range(slice_count):
+                img = st.camera_input(f"Frame {i} - Cam 0", key=f"cam0_frame_{i}_{time.time()}")
+                if img:
+                    filename = generate_filename(f"0_{i}")
+                    with open(filename, "wb") as f:
+                        f.write(img.getvalue())
+                    st.session_state['cam0_frames'].append(filename)
+                    logger.info(f"Saved frame {i} from Camera 0: {filename}")
+                    time.sleep(1.0 / slice_count)
+            st.session_state['captured_images'].extend(st.session_state['cam0_frames'])
+            update_gallery()
+            for frame in st.session_state['cam0_frames']:
+                st.image(Image.open(frame), caption=frame, use_container_width=True)
     with cols[1]:
-        st.subheader(f"Camera 1 ({cam1_device}) 🎥")
-        cam1_img = st.camera_input(
-            label=cam1_label,
-            key="cam1",
-            help=cam1_help,
-            disabled=False,
-            label_visibility=cam1_vis
-        )
+        st.subheader("Camera 1")
+        cam1_img = st.camera_input("Take a picture - Cam 1", key="cam1")
         if cam1_img:
-            filename = generate_filename("cam1")
+            filename = generate_filename(1)
             with open(filename, "wb") as f:
                 f.write(cam1_img.getvalue())
             st.image(Image.open(filename), caption=filename, use_container_width=True)
             logger.info(f"Saved snapshot from Camera 1: {filename}")
             st.session_state['captured_images'].append(filename)
             update_gallery()
-        st.info("🚨 Single shots only—craft your masterpiece! 🎨")
+        if st.button(f"Capture {slice_count} Frames - Cam 1 📸"):
+            st.session_state['cam1_frames'] = []
+            for i in range(slice_count):
+                img = st.camera_input(f"Frame {i} - Cam 1", key=f"cam1_frame_{i}_{time.time()}")
+                if img:
+                    filename = generate_filename(f"1_{i}")
+                    with open(filename, "wb") as f:
+                        f.write(img.getvalue())
+                    st.session_state['cam1_frames'].append(filename)
+                    logger.info(f"Saved frame {i} from Camera 1: {filename}")
+                    time.sleep(1.0 / slice_count)
+            st.session_state['captured_images'].extend(st.session_state['cam1_frames'])
+            update_gallery()
+            for frame in st.session_state['cam1_frames']:
+                st.image(Image.open(frame), caption=frame, use_container_width=True)
 
-with tab3:
-    st.header("Fine-Tune Titan (CV) 🔧 (Sculpt Your Pixel Prodigy!)")
-    if not st.session_state['cv_loaded'] or not isinstance(st.session_state['cv_builder'], (MicroDiffusionBuilder, LatentDiffusionBuilder, FluxDiffusionBuilder)):
-        st.warning("Please build or load a CV Titan first! ⚠️ (No artist, no canvas!)")
+with tab2:
+    st.header("Fine-Tune Titan 🔧")
+    if 'builder' not in st.session_state or not st.session_state.get('model_loaded', False):
+        st.warning("Please build or load a Titan first! ⚠️")
     else:
-        captured_images = get_gallery_files(["png"])
-        if len(captured_images) >= 2:
-            st.subheader("Use Case 1: Denoise Snapshots 🌟")
-            denoising_data = [{"image": img, "text": f"Denoised {os.path.basename(img).split('-')[4]} snap"} for img in captured_images[:min(len(captured_images), 10)]]
-            denoising_edited = st.data_editor(pd.DataFrame(denoising_data), num_rows="dynamic", help="Craft denoising pairs! 🌟")
-            if st.button("Fine-Tune Denoising 🔄"):
-                images = [Image.open(row["image"]) for _, row in denoising_edited.iterrows()]
-                texts = [row["text"] for _, row in denoising_edited.iterrows()]
-                new_model_name = f"{st.session_state['cv_builder'].config.name}-denoise-{int(time.time())}"
-                new_config = DiffusionConfig(name=new_model_name, base_model=st.session_state['cv_builder'].config.base_model, size="small")
-                st.session_state['cv_builder'].config = new_config
-                with st.status("Fine-tuning for denoising... ⏳ (Polishing pixels!)", expanded=True) as status:
-                    st.session_state['cv_builder'].fine_tune_sft(images, texts)
-                    st.session_state['cv_builder'].save_model(new_config.model_path)
-                    status.update(label="Denoising tuned! 🎉 (Pixel shine unleashed!)", state="complete")
-                zip_path = f"{new_config.model_path}.zip"
-                zip_files([new_config.model_path], zip_path)
-                st.markdown(get_download_link(zip_path, "application/zip", "Download Denoised Titan 📦"), unsafe_allow_html=True)
-            denoising_csv = f"denoise_dataset_{int(time.time())}.csv"
-            with open(denoising_csv, "w", newline="") as f:
-                writer = csv.writer(f)
-                writer.writerow(["image", "text"])
-                for _, row in denoising_edited.iterrows():
-                    writer.writerow([row["image"], row["text"]])
-            st.markdown(get_download_link(denoising_csv, "text/csv", "Download Denoising CSV 📜"), unsafe_allow_html=True)
-
-            st.subheader("Use Case 2: Stylize Snapshots 🎨")
-            stylize_data = [{"image": img, "text": f"Neon {os.path.basename(img).split('-')[4]} style"} for img in captured_images[:min(len(captured_images), 10)]]
-            stylize_edited = st.data_editor(pd.DataFrame(stylize_data), num_rows="dynamic", help="Craft stylized pairs! 🎨")
-            if st.button("Fine-Tune Stylization 🔄"):
-                images = [Image.open(row["image"]) for _, row in stylize_edited.iterrows()]
-                texts = [row["text"] for _, row in stylize_edited.iterrows()]
-                new_model_name = f"{st.session_state['cv_builder'].config.name}-stylize-{int(time.time())}"
-                new_config = DiffusionConfig(name=new_model_name, base_model=st.session_state['cv_builder'].config.base_model, size="small")
-                st.session_state['cv_builder'].config = new_config
-                with st.status("Fine-tuning for stylization... ⏳ (Painting pixels!)", expanded=True) as status:
-                    st.session_state['cv_builder'].fine_tune_sft(images, texts)
-                    st.session_state['cv_builder'].save_model(new_config.model_path)
-                    status.update(label="Stylization tuned! 🎉 (Pixel art unleashed!)", state="complete")
-                zip_path = f"{new_config.model_path}.zip"
-                zip_files([new_config.model_path], zip_path)
-                st.markdown(get_download_link(zip_path, "application/zip", "Download Stylized Titan 📦"), unsafe_allow_html=True)
-            stylize_md = f"stylize_dataset_{int(time.time())}.md"
-            with open(stylize_md, "w") as f:
-                f.write("# Stylization Dataset\n\n")
-                for _, row in stylize_edited.iterrows():
-                    f.write(f"- `{row['image']}`: {row['text']}\n")
-            st.markdown(get_download_link(stylize_md, "text/markdown", "Download Stylization MD 📝"), unsafe_allow_html=True)
-
-            st.subheader("Use Case 3: Multi-Angle Snapshots 🌐")
-            multiangle_data = [{"image": img, "text": f"View from {os.path.basename(img).split('-')[4]}"} for img in captured_images[:min(len(captured_images), 10)]]
-            multiangle_edited = st.data_editor(pd.DataFrame(multiangle_data), num_rows="dynamic", help="Craft multi-angle pairs! 🌐")
-            if st.button("Fine-Tune Multi-Angle 🔄"):
-                images = [Image.open(row["image"]) for _, row in multiangle_edited.iterrows()]
-                texts = [row["text"] for _, row in multiangle_edited.iterrows()]
-                new_model_name = f"{st.session_state['cv_builder'].config.name}-multiangle-{int(time.time())}"
-                new_config = DiffusionConfig(name=new_model_name, base_model=st.session_state['cv_builder'].config.base_model, size="small")
-                st.session_state['cv_builder'].config = new_config
-                with st.status("Fine-tuning for multi-angle... ⏳ (Spinning pixels!)", expanded=True) as status:
-                    st.session_state['cv_builder'].fine_tune_sft(images, texts)
-                    st.session_state['cv_builder'].save_model(new_config.model_path)
-                    status.update(label="Multi-angle tuned! 🎉 (Pixel views unleashed!)", state="complete")
+        if isinstance(st.session_state['builder'], ModelBuilder):
+            uploaded_csv = st.file_uploader("Upload CSV for SFT", type="csv")
+            if uploaded_csv and st.button("Fine-Tune with Uploaded CSV 🔄"):
+                csv_path = f"uploaded_sft_data_{int(time.time())}.csv"
+                with open(csv_path, "wb") as f:
+                    f.write(uploaded_csv.read())
+                new_model_name = f"{st.session_state['builder'].config.name}-sft-{int(time.time())}"
+                new_config = ModelConfig(name=new_model_name, base_model=st.session_state['builder'].config.base_model, size="small")
+                st.session_state['builder'].config = new_config
+                st.session_state['builder'].fine_tune_sft(csv_path)
+                st.session_state['builder'].save_model(new_config.model_path)
                 zip_path = f"{new_config.model_path}.zip"
-                zip_files([new_config.model_path], zip_path)
-                st.markdown(get_download_link(zip_path, "application/zip", "Download Multi-Angle Titan 📦"), unsafe_allow_html=True)
-            multiangle_csv = f"multiangle_dataset_{int(time.time())}.csv"
-            with open(multiangle_csv, "w", newline="") as f:
-                writer = csv.writer(f)
-                writer.writerow(["image", "text"])
-                for _, row in multiangle_edited.iterrows():
-                    writer.writerow([row["image"], row["text"]])
-            st.markdown(get_download_link(multiangle_csv, "text/csv", "Download Multi-Angle CSV 📜"), unsafe_allow_html=True)
+                zip_directory(new_config.model_path, zip_path)
+                st.markdown(get_download_link(zip_path, "application/zip", "Download Fine-Tuned Titan"), unsafe_allow_html=True)
+        elif isinstance(st.session_state['builder'], DiffusionBuilder):
+            captured_images = get_gallery_files(["png"])
+            if len(captured_images) >= 2:
+                demo_data = [{"image": img, "text": f"Superhero {os.path.basename(img).split('.')[0]}"} for img in captured_images[:min(len(captured_images), slice_count)]]
+                edited_data = st.data_editor(pd.DataFrame(demo_data), num_rows="dynamic")
+                if st.button("Fine-Tune with Dataset 🔄"):
+                    images = [Image.open(row["image"]) for _, row in edited_data.iterrows()]
+                    texts = [row["text"] for _, row in edited_data.iterrows()]
+                    new_model_name = f"{st.session_state['builder'].config.name}-sft-{int(time.time())}"
+                    new_config = DiffusionConfig(name=new_model_name, base_model=st.session_state['builder'].config.base_model, size="small")
+                    st.session_state['builder'].config = new_config
+                    st.session_state['builder'].fine_tune_sft(images, texts)
+                    st.session_state['builder'].save_model(new_config.model_path)
+                    zip_path = f"{new_config.model_path}.zip"
+                    zip_directory(new_config.model_path, zip_path)
+                    st.markdown(get_download_link(zip_path, "application/zip", "Download Fine-Tuned Diffusion Model"), unsafe_allow_html=True)
+                csv_path = f"sft_dataset_{int(time.time())}.csv"
+                with open(csv_path, "w", newline="") as f:
+                    writer = csv.writer(f)
+                    writer.writerow(["image", "text"])
+                    for _, row in edited_data.iterrows():
+                        writer.writerow([row["image"], row["text"]])
+                st.markdown(get_download_link(csv_path, "text/csv", "Download SFT Dataset CSV"), unsafe_allow_html=True)
+
+with tab3:
+    st.header("Build Titan 🌱")
+    model_type = st.selectbox("Model Type", ["Causal LM", "Diffusion"], key="build_type")
+    base_model_options = {
+        "Causal LM": ["HuggingFaceTB/SmolLM-135M", "Qwen/Qwen1.5-0.5B-Chat"],
+        "Diffusion": [
+            "OFA-Sys/small-stable-diffusion-v0 (LDM/Conditional)", 
+            "google/ddpm-ema-celebahq-256 (DDPM/SDE/Autoregressive Proxy)"
+        ]
+    }
+    base_model = st.selectbox("Select Tiny Model", base_model_options[model_type])
+    model_name = st.text_input("Model Name", f"tiny-titan-{int(time.time())}")
+    if st.button("Download Model ⬇️"):
+        config = (ModelConfig if model_type == "Causal LM" else DiffusionConfig)(name=model_name, base_model=base_model.split(" ")[0], size="small")
+        builder = ModelBuilder() if model_type == "Causal LM" else DiffusionBuilder()
+        model_type_for_diffusion = "StableDiffusion" if "small-stable-diffusion" in base_model else "DDPM"
+        builder.load_model(base_model.split(" ")[0], config, model_type_for_diffusion)
+        builder.save_model(config.model_path)
+        st.session_state['builder'] = builder
+        st.session_state['model_loaded'] = True
+        st.rerun()
 
 with tab4:
-    st.header("Test Titan (CV) 🧪 (Unleash Your Pixel Power!)")
-    if not st.session_state['cv_loaded'] or not isinstance(st.session_state['cv_builder'], (MicroDiffusionBuilder, LatentDiffusionBuilder, FluxDiffusionBuilder)):
-        st.warning("Please build or load a CV Titan first! ⚠️ (No artist, no masterpiece!)")
+    st.header("Test Titan 🧪")
+    if 'builder' not in st.session_state or not st.session_state.get('model_loaded', False):
+        st.warning("Please build or load a Titan first! ⚠️")
     else:
-        st.subheader("Test Your Titan 🎨")
-        test_prompt = st.text_area("Prompt 🎤", "Neon glow from cam0", help="Dream up a wild image—your Titan’s ready to paint! 🖌️")
-        if st.button("Generate ▶️"):
-            with st.spinner("Crafting your masterpiece... ⏳ (Titan’s mixing pixels!)"):
-                image = st.session_state['cv_builder'].generate(test_prompt)
-                st.image(image, caption=f"Generated: {test_prompt}", use_container_width=True)
+        captured_images = get_gallery_files(["png"])
+        if captured_images:
+            selected_image = st.selectbox("Select Image", captured_images)
+            prompt = st.text_area("Enter Text Prompt", f"Superhero {os.path.basename(selected_image).split('.')[0]}")
+            pipeline_options = ["Stable Diffusion (LDM/Conditional)", "DDPM (DDPM/SDE/Autoregressive Proxy)"] if isinstance(st.session_state['builder'], DiffusionBuilder) else ["Causal LM"]
+            selected_pipeline = st.selectbox("Select Pipeline", pipeline_options)
+            if st.button("Run Test 🚀"):
+                if isinstance(st.session_state['builder'], ModelBuilder):
+                    result = st.session_state['builder'].evaluate(prompt)
+                    st.write(f"**Generated Response**: {result}")
+                elif isinstance(st.session_state['builder'], DiffusionBuilder):
+                    if selected_pipeline == "Stable Diffusion (LDM/Conditional)":
+                        image = st.session_state['builder'].generate(prompt)
+                    else:  # DDPM
+                        image = st.session_state['builder'].generate(prompt)
+                    st.image(image, caption=f"Generated from {selected_pipeline}")
 
 with tab5:
-    st.header("Agentic RAG Party (CV) 🌐 (Pixel Party Extravaganza!)")
-    st.write("Generate superhero party vibes from your tuned Titan! 🎉")
-    if not st.session_state['cv_loaded'] or not isinstance(st.session_state['cv_builder'], (MicroDiffusionBuilder, LatentDiffusionBuilder, FluxDiffusionBuilder)):
-        st.warning("Please build or load a CV Titan first! ⚠️ (No artist, no party!)")
+    st.header("Agentic RAG Party 🌐")
+    if 'builder' not in st.session_state or not st.session_state.get('model_loaded', False):
+        st.warning("Please build or load a Titan first! ⚠️")
     else:
-        if st.button("Run RAG Demo 🎉"):
-            with st.spinner("Loading your pixel party titan... ⏳ (Titan’s grabbing its brush!)"):
-                class CVPartyAgent:
-                    def __init__(self, pipeline):
-                        self.pipeline = pipeline
-                    def generate(self, prompt: str) -> Image.Image:
-                        return self.pipeline(prompt, num_inference_steps=50).images[0]
-                    def plan_party(self):
-                        prompts = [
-                            "Gold-plated Batman statue from cam0",
-                            "VR superhero battle scene from cam1",
-                            "Neon-lit Avengers tower from cam2"
-                        ]
-                        data = [{"Theme": f"Scene {i+1}", "Image Idea": prompt} for i, prompt in enumerate(prompts)]
-                        return pd.DataFrame(data)
-                agent = CVPartyAgent(st.session_state['cv_builder'].pipeline)
-                st.write("Party agent ready! 🎨 (Time to paint an epic bash!)")
-            with st.spinner("Crafting superhero party visuals... ⏳ (Pixels assemble!)"):
-                try:
-                    plan_df = agent.plan_party()
-                    st.dataframe(plan_df)
-                    for _, row in plan_df.iterrows():
-                        image = agent.generate(row["Image Idea"])
-                        st.image(image, caption=f"{row['Theme']} - {row['Image Idea']}", use_container_width=True)
-                except Exception as e:
-                    st.error(f"Party crashed: {str(e)} 💥 (Pixel oopsie!)")
-                    logger.error(f"RAG demo failed: {str(e)}")
-
+        if isinstance(st.session_state['builder'], ModelBuilder):
+            if st.button("Run NLP RAG Demo 🎉"):
+                agent = PartyPlannerAgent(st.session_state['builder'].model, st.session_state['builder'].tokenizer)
+                task = "Plan a luxury superhero-themed party at Wayne Manor."
+                plan_df = agent.plan_party(task)
+                st.dataframe(plan_df)
+        elif isinstance(st.session_state['builder'], DiffusionBuilder):
+            if st.button("Run CV RAG Demo 🎉"):
+                agent = CVPartyPlannerAgent(st.session_state['builder'].pipeline)
+                task = "Generate images for a luxury superhero-themed party."
+                plan_df = agent.plan_party(task)
+                st.dataframe(plan_df)
+                for _, row in plan_df.iterrows():
+                    image = agent.generate(row["Image Idea"])
+                    st.image(image, caption=f"{row['Theme']} - {row['Image Idea']}")
+
+# Display Logs
 st.sidebar.subheader("Action Logs 📜")
 log_container = st.sidebar.empty()
 with log_container:
     for record in log_records:
         st.write(f"{record.asctime} - {record.levelname} - {record.message}")
 
+# Initial Gallery Update
 update_gallery()