Update app.py

app.py

@@ -19,27 +19,18 @@ import random
 import logging
 from datetime import datetime
 import pytz
-from diffusers import StableDiffusionPipeline  # For diffusion models
+from diffusers import StableDiffusionPipeline
 from urllib.parse import quote
+import cv2
 
-# Set up logging
+# Logging setup
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # Page Configuration
-st.set_page_config(
-    page_title="SFT Tiny Titans 🚀",
-    page_icon="🤖",
-    layout="wide",
-    initial_sidebar_state="expanded",
-    menu_items={
-        'Get Help': 'https://huggingface.co/awacke1',
-        'Report a bug': 'https://huggingface.co/spaces/awacke1',
-        'About': "Tiny Titans: Small models, big dreams, and a sprinkle of chaos! 🌌"
-    }
-)
+st.set_page_config(page_title="SFT Tiny Titans 🚀", page_icon="🤖", layout="wide", initial_sidebar_state="expanded")
 
-# Model Configuration Classes
+# Model Configurations
 @dataclass
 class ModelConfig:
     name: str
@@ -47,7 +38,6 @@ class ModelConfig:
     size: str
     domain: Optional[str] = None
     model_type: str = "causal_lm"
-    
     @property
     def model_path(self):
         return f"models/{self.name}"
@@ -57,7 +47,6 @@ class DiffusionConfig:
     name: str
     base_model: str
     size: str
-    
     @property
     def model_path(self):
         return f"diffusion_models/{self.name}"
@@ -68,10 +57,8 @@ class SFTDataset(Dataset):
         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"]
@@ -90,133 +77,103 @@ class DiffusionDataset(Dataset):
     def __init__(self, images, texts):
         self.images = images
         self.texts = texts
-
     def __len__(self):
         return len(self.images)
-
     def __getitem__(self, idx):
         return {"image": self.images[idx], "text": self.texts[idx]}
 
-# Model Builder Classes
+# Model Builders
 class ModelBuilder:
     def __init__(self):
         self.config = None
         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
-        st.success(f"Model loaded! 🎉 {random.choice(self.jokes)}")
+        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
         return self
-
     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)}")
+            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}")
         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):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        self.model.save_pretrained(path)
+        self.tokenizer.save_pretrained(path)
+    def evaluate(self, prompt: str):
         self.model.eval()
-        if status_container:
-            status_container.write("Preparing to evaluate... 🧠")
-        try:
-            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:
-            if status_container:
-                status_container.error(f"Oops! Something broke: {str(e)} 💥")
-            return f"Error: {str(e)}"
+        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)
 
 class DiffusionBuilder:
     def __init__(self):
         self.config = None
         self.pipeline = None
-
     def load_model(self, model_path: str, config: Optional[DiffusionConfig] = None):
-        with st.spinner(f"Loading diffusion model {model_path}... ⏳"):
-            self.pipeline = StableDiffusionPipeline.from_pretrained(model_path)
-            self.pipeline.to("cuda" if torch.cuda.is_available() else "cpu")
-            if config:
-                self.config = config
-        st.success(f"Diffusion model loaded! 🎨")
+        self.pipeline = StableDiffusionPipeline.from_pretrained(model_path)
+        self.pipeline.to("cuda" if torch.cuda.is_available() else "cpu")
+        if config:
+            self.config = config
         return self
-
     def fine_tune_sft(self, images, texts, epochs=3):
         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"].to(self.pipeline.device)
-                    text = batch["text"]
-                    latents = self.pipeline.vae.encode(image).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! 🎨")
+            total_loss = 0
+            for batch in dataloader:
+                optimizer.zero_grad()
+                image = batch["image"].to(self.pipeline.device)
+                text = batch["text"]
+                latents = self.pipeline.vae.encode(image).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}")
         return self
-
     def save_model(self, path: str):
-        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}! ✅")
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        self.pipeline.save_pretrained(path)
+    def generate(self, prompt: str):
+        return self.pipeline(prompt, num_inference_steps=50).images[0]
 
-# Utility Functions
+# Utilities
 def get_download_link(file_path, mime_type="text/plain", label="Download"):
     with open(file_path, 'rb') as f:
         data = f.read()
@@ -227,19 +184,14 @@ 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:
-                file_path = os.path.join(root, file)
-                arcname = os.path.relpath(file_path, os.path.dirname(directory_path))
-                zipf.write(file_path, arcname)
+                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):
-    files = []
-    for ext in file_types:
-        files.extend(glob.glob(f"*.{ext}"))
-    return sorted(files)
+    return sorted([f for ext in file_types for f in glob.glob(f"*.{ext}")])
 
 def generate_filename(text_line):
     central = pytz.timezone('US/Central')
@@ -254,39 +206,55 @@ def display_search_links(query):
         "Google": f"https://www.google.com/search?q={quote(query)}",
         "YouTube": f"https://www.youtube.com/results?search_query={quote(query)}"
     }
-    links_md = ' '.join([f"[{name}]({url})" for name, url in search_urls.items()])
-    return links_md
-
-# Agent Class
-class PartyPlannerAgent:
+    return ' '.join([f"[{name}]({url})" for name, url in search_urls.items()])
+
+def detect_cameras():
+    cameras = []
+    for i in range(2):  # Check first two indices
+        cap = cv2.VideoCapture(i)
+        if cap.isOpened():
+            cameras.append(i)
+            cap.release()
+    return cameras
+
+# Agent Classes
+class NLPAgent:
     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 = "Latest trends for 2025: Gold-plated Batman statues, VR superhero battles."
         prompt = f"Given this context: '{search_result}'\n{task}"
         plan_text = self.generate(prompt)
         st.markdown(f"Search Links: {display_search_links('superhero party trends')}", unsafe_allow_html=True)
-        
-        locations = {"Wayne Manor": (42.3601, -71.0589), "New York": (40.7128, -74.0060), "Los Angeles": (34.0522, -118.2437), "London": (51.5074, -0.1278)}
-        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"}
-        
+        locations = {"Wayne Manor": (42.3601, -71.0589), "New York": (40.7128, -74.0060)}
+        travel_times = {loc: calculate_cargo_travel_time(coords, locations["Wayne Manor"]) for loc, coords in locations.items() if loc != "Wayne Manor"}
+        data = [
+            {"Location": "New York", "Travel Time (hrs)": travel_times["New York"], "Idea": "Gold-plated Batman statues"},
+            {"Location": "Wayne Manor", "Travel Time (hrs)": 0.0, "Idea": "VR superhero battles"}
+        ]
+        return pd.DataFrame(data)
+
+class CVAgent:
+    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 enhance_images(self, task: str) -> pd.DataFrame:
+        search_result = "Latest superhero art trends: Neon outlines, 3D holograms."
+        prompt = f"Given this context: '{search_result}'\n{task}"
+        st.markdown(f"Search Links: {display_search_links('superhero art trends')}", unsafe_allow_html=True)
         data = [
-            {"Location": "New York", "Travel Time (hrs)": travel_times["New York"], "Luxury Idea": "Gold-plated Batman statues"},
-            {"Location": "Los Angeles", "Travel Time (hrs)": travel_times["Los Angeles"], "Luxury Idea": "VR superhero battles"},
-            {"Location": "London", "Travel Time (hrs)": travel_times["London"], "Luxury Idea": "Live stunt shows"},
-            {"Location": "Wayne Manor", "Travel Time (hrs)": 0.0, "Luxury Idea": "Holographic displays"}
+            {"Image Theme": "Batman", "Enhancement": "Neon outlines"},
+            {"Image Theme": "Iron Man", "Enhancement": "3D holograms"}
         ]
         return pd.DataFrame(data)
 
@@ -309,52 +277,59 @@ def calculate_cargo_travel_time(origin_coords: Tuple[float, float], destination_
 st.title("SFT Tiny Titans 🚀 (Small but Mighty!)")
 
 # Sidebar Galleries
-st.sidebar.header("Galleries 🎨")
-for gallery_type, file_types in [
-    ("Image Gallery 📸", ["png", "jpg", "jpeg"]),
-    ("Video Gallery 🎥", ["mp4"]),
-    ("Audio Gallery 🎶", ["mp3"])
+st.sidebar.header("Shared Galleries 🎨")
+for gallery_type, file_types, emoji in [
+    ("Images 📸", ["png", "jpg", "jpeg"], "🖼️"),
+    ("Videos 🎥", ["mp4"], "🎬"),
+    ("Audio 🎶", ["mp3"], "🎵")
 ]:
-    st.sidebar.subheader(gallery_type)
+    st.sidebar.subheader(f"{gallery_type} {emoji}")
     files = get_gallery_files(file_types)
     if files:
         cols_num = st.sidebar.slider(f"{gallery_type} Columns", 1, 5, 3, key=f"{gallery_type}_cols")
         cols = st.sidebar.columns(cols_num)
         for idx, file in enumerate(files[:cols_num * 2]):
             with cols[idx % cols_num]:
-                if "Image" in gallery_type:
+                if "Images" in gallery_type:
                     st.image(Image.open(file), caption=file, use_column_width=True)
-                elif "Video" in gallery_type:
+                elif "Videos" in gallery_type:
                     st.video(file)
                 elif "Audio" in gallery_type:
                     st.audio(file)
 
 st.sidebar.subheader("Model Management 🗂️")
-model_type = st.sidebar.selectbox("Model Type", ["Causal LM", "Diffusion"])
-model_dirs = get_model_files("causal_lm" if model_type == "Causal LM" else "diffusion")
+model_type = st.sidebar.selectbox("Model Type", ["NLP (Causal LM)", "CV (Diffusion)"])
+model_dirs = get_model_files("causal_lm" if "NLP" in model_type else "diffusion")
 selected_model = st.sidebar.selectbox("Select Saved Model", ["None"] + model_dirs)
 if selected_model != "None" and st.sidebar.button("Load Model 📂"):
-    if 'builder' not in st.session_state:
-        st.session_state['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")
-    st.session_state['builder'].load_model(selected_model, config)
+    builder = ModelBuilder() if "NLP" in model_type else DiffusionBuilder()
+    config = (ModelConfig if "NLP" in model_type 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()
 
 # Tabs
-tab1, tab2, tab3, tab4, tab5 = st.tabs(["Build Tiny Titan 🌱", "Fine-Tune Titan 🔧", "Test Titan 🧪", "Agentic RAG Party 🌐", "Diffusion SFT 🎨"])
+tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
+    "Build Titan 🌱",
+    "Fine-Tune NLP 🧠",
+    "Fine-Tune CV 🎨",
+    "Test Titans 🧪",
+    "Agentic RAG 🌀",
+    "Camera Inputs 📷"
+])
 
 with tab1:
-    st.header("Build Tiny Titan 🌱")
-    model_type = st.selectbox("Model Type", ["Causal LM", "Diffusion"], key="build_type")
-    if model_type == "Causal LM":
-        base_model = st.selectbox("Select Tiny Model", ["HuggingFaceTB/SmolLM-135M", "HuggingFaceTB/SmolLM-360M", "Qwen/Qwen1.5-0.5B-Chat"])
-    else:
-        base_model = st.selectbox("Select Tiny Diffusion Model", ["stabilityai/stable-diffusion-2-1", "runwayml/stable-diffusion-v1-5", "CompVis/stable-diffusion-v1-4"])
+    st.header("Build Your Titan 🌱")
+    model_type = st.selectbox("Model Type", ["NLP (Causal LM)", "CV (Diffusion)"], key="build_type")
+    base_model = st.selectbox(
+        "Select Tiny Model",
+        ["HuggingFaceTB/SmolLM-135M", "Qwen/Qwen1.5-0.5B-Chat"] if "NLP" in model_type else ["stabilityai/stable-diffusion-2-1", "CompVis/stable-diffusion-v1-4"]
+    )
     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, size="small")
-        builder = ModelBuilder() if model_type == "Causal LM" else DiffusionBuilder()
+        config = (ModelConfig if "NLP" in model_type else DiffusionConfig)(name=model_name, base_model=base_model, size="small")
+        builder = ModelBuilder() if "NLP" in model_type else DiffusionBuilder()
         builder.load_model(base_model, config)
         builder.save_model(config.model_path)
         st.session_state['builder'] = builder
@@ -362,72 +337,146 @@ with tab1:
         st.rerun()
 
 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:
-        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_directory(new_config.model_path, zip_path)
-                st.markdown(get_download_link(zip_path, "application/zip", "Download Fine-Tuned Titan"), unsafe_allow_html=True)
-
-with tab3:
-    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:
-        if isinstance(st.session_state['builder'], ModelBuilder):
-            test_prompt = st.text_area("Enter Test Prompt", "What is AI?")
-            if st.button("Run Test ▶️"):
-                result = st.session_state['builder'].evaluate(test_prompt)
-                st.write(f"**Generated Response**: {result}")
-
-with tab4:
-    st.header("Agentic RAG Party 🌐")
+    st.header("Fine-Tune NLP Titan 🧠 (Word Wizardry!)")
     if 'builder' not in st.session_state or not st.session_state.get('model_loaded', False) or not isinstance(st.session_state['builder'], ModelBuilder):
-        st.warning("Please build or load a Causal LM Titan first! ⚠️")
+        st.warning("Load an NLP Titan first! ⚠️")
     else:
-        if st.button("Run Agentic RAG Demo 🎉"):
-            agent = PartyPlannerAgent(model=st.session_state['builder'].model, tokenizer=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)
+        uploaded_csv = st.file_uploader("Upload CSV for NLP SFT", type="csv", key="nlp_csv")
+        if uploaded_csv and st.button("Tune the Wordsmith 🔧"):
+            csv_path = f"nlp_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_directory(new_config.model_path, zip_path)
+            st.markdown(get_download_link(zip_path, "application/zip", "Download Tuned NLP Titan"), unsafe_allow_html=True)
 
-with tab5:
-    st.header("Diffusion SFT 🎨")
+with tab3:
+    st.header("Fine-Tune CV Titan 🎨 (Vision Vibes!)")
     if 'builder' not in st.session_state or not st.session_state.get('model_loaded', False) or not isinstance(st.session_state['builder'], DiffusionBuilder):
-        st.warning("Please build or load a Diffusion Titan first! ⚠️")
+        st.warning("Load a CV Titan first! ⚠️")
     else:
-        uploaded_files = st.file_uploader("Upload Images/Videos", type=["png", "jpg", "jpeg", "mp4", "mp3"], accept_multiple_files=True)
-        text_input = st.text_area("Enter Text (one line per image)", "Line 1\nLine 2\nLine 3")
-        if uploaded_files and st.button("Fine-Tune Diffusion Model 🔄"):
+        uploaded_files = st.file_uploader("Upload Images/Videos", type=["png", "jpg", "jpeg", "mp4", "mp3"], accept_multiple_files=True, key="cv_upload")
+        text_input = st.text_area("Enter Text (one line per image)", "Batman Neon\nIron Man Hologram\nThor Lightning", key="cv_text")
+        if uploaded_files and st.button("Tune the Visionary 🖌️"):
             images = [Image.open(f) for f in uploaded_files if f.type.startswith("image")]
             texts = text_input.splitlines()
             if len(images) > len(texts):
                 texts.extend([""] * (len(images) - len(texts)))
             elif len(texts) > len(images):
                 texts = texts[:len(images)]
-            
             st.session_state['builder'].fine_tune_sft(images, texts)
             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'].save_model(new_config.model_path)
-            
             for img, text in zip(images, texts):
                 filename = generate_filename(text)
                 img.save(filename)
                 st.image(img, caption=filename)
             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)
+            st.markdown(get_download_link(zip_path, "application/zip", "Download Tuned CV Titan"), unsafe_allow_html=True)
+
+with tab4:
+    st.header("Test Titans 🧪 (Brains & Eyes!)")
+    if 'builder' not in st.session_state or not st.session_state.get('model_loaded', False):
+        st.warning("Load a Titan first! ⚠️")
+    else:
+        if isinstance(st.session_state['builder'], ModelBuilder):
+            st.subheader("NLP Test 🧠")
+            test_prompt = st.text_area("Enter NLP Prompt", "Plan a superhero party!", key="nlp_test")
+            if st.button("Test NLP Titan ▶️"):
+                result = st.session_state['builder'].evaluate(test_prompt)
+                st.write(f"**Response**: {result}")
+        elif isinstance(st.session_state['builder'], DiffusionBuilder):
+            st.subheader("CV Test 🎨")
+            test_prompt = st.text_area("Enter CV Prompt", "Superhero in neon style", key="cv_test")
+            if st.button("Test CV Titan ▶️"):
+                image = st.session_state['builder'].generate(test_prompt)
+                st.image(image, caption="Generated Image")
+
+            cameras = detect_cameras()
+            if cameras:
+                st.subheader("Camera Snapshot Test 📷")
+                camera_idx = st.selectbox("Select Camera", cameras, key="camera_select")
+                snapshot_text = st.text_input("Snapshot Text", "Camera Snap", key="snap_text")
+                if st.button("Capture Snapshot 📸"):
+                    cap = cv2.VideoCapture(camera_idx)
+                    ret, frame = cap.read()
+                    if ret:
+                        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                        img = Image.fromarray(rgb_frame)
+                        filename = generate_filename(snapshot_text)
+                        img.save(filename)
+                        st.image(img, caption=filename)
+                    cap.release()
+
+with tab5:
+    st.header("Agentic RAG 🌀 (Smart Plans & Visions!)")
+    if 'builder' not in st.session_state or not st.session_state.get('model_loaded', False):
+        st.warning("Load a Titan first! ⚠️")
+    else:
+        if isinstance(st.session_state['builder'], ModelBuilder):
+            st.subheader("NLP RAG Party 🧠")
+            if st.button("Run NLP RAG Demo 🎉"):
+                agent = NLPAgent(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):
+            st.subheader("CV RAG Enhance 🎨")
+            if st.button("Run CV RAG Demo 🖌️"):
+                agent = CVAgent(st.session_state['builder'].pipeline)
+                task = "Enhance superhero images with 2025 trends."
+                enhance_df = agent.enhance_images(task)
+                st.dataframe(enhance_df)
+
+with tab6:
+    st.header("Camera Inputs 📷 (Live Feed Fun!)")
+    cameras = detect_cameras()
+    if not cameras:
+        st.warning("No cameras detected! ⚠️")
+    else:
+        st.write(f"Detected {len(cameras)} cameras!")
+        for idx in cameras:
+            st.subheader(f"Camera {idx}")
+            cap = cv2.VideoCapture(idx)
+            if st.button(f"Capture from Camera {idx} 📸", key=f"cap_{idx}"):
+                ret, frame = cap.read()
+                if ret:
+                    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    img = Image.fromarray(rgb_frame)
+                    filename = generate_filename(f"Camera_{idx}_snap")
+                    img.save(filename)
+                    st.image(img, caption=filename)
+            cap.release()
+
+    # Preload demo files
+    demo_images = ["20250319_010000_AM_Batman.png", "20250319_010001_AM_IronMan.png", "20250319_010002_AM_Thor.png"]
+    demo_videos = ["20250319_010000_AM_Batman.mp4", "20250319_010001_AM_IronMan.mp4", "20250319_010002_AM_Thor.mp4"]
+    for img in demo_images:
+        if not os.path.exists(img):
+            Image.new("RGB", (100, 100)).save(img)
+    for vid in demo_videos:
+        if not os.path.exists(vid):
+            with open(vid, "wb") as f:
+                f.write(b"")  # Dummy file
+
+    # Demo SFT Dataset
+    st.subheader("Diffusion SFT Demo Dataset 🎨")
+    demo_texts = ["Batman Neon", "Iron Man Hologram", "Thor Lightning"]
+    demo_code = "\n".join([f"{i+1}. {text} -> {demo_images[i]}" for i, text in enumerate(demo_texts)])
+    st.code(demo_code, language="text")
+    if st.button("Download Demo CSV 📝"):
+        csv_path = f"demo_diffusion_sft_{int(time.time())}.csv"
+        with open(csv_path, "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["image", "text"])
+            for img, text in zip(demo_images, demo_texts):
+                writer.writerow([img, text])
+        st.markdown(get_download_link(csv_path, "text/csv", "Download Demo CSV"), unsafe_allow_html=True)