Spaces:

Kuberwastaken
/

TREAT

Running

App Files Files Community

Kuberwastaken commited on 30 days ago

Commit

83c0537

1 Parent(s): b4a4d6e

Improved functionality

Browse files

Files changed (2) hide show

gradio_app.py +99 -134
model/analyzer.py +224 -197

gradio_app.py CHANGED Viewed

@@ -1,172 +1,137 @@
 import gradio as gr
-import time
 from model.analyzer import analyze_content
-# Custom CSS for the interface
-css = """
-@import url('https://fonts.googleapis.com/css2?family=Nunito:wght@400;700&display=swap');
-#treat-container {
-    background: linear-gradient(135deg, #ffE6F0 0%, #E6F0FF 100%);
-    padding: 2rem;
-    border-radius: 20px;
-    box-shadow: 0 8px 32px rgba(0,0,0,0.1);
-    font-family: 'Nunito', sans-serif;
 }
-#treat-title {
-    text-align: center;
-    color: #FF69B4;
-    font-size: 3.5rem;
     font-weight: bold;
-    margin-bottom: 0.5rem;
-    text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
 }
-#treat-subtitle {
-    text-align: center;
-    color: #666;
-    font-size: 1.2rem;
-    margin-bottom: 2rem;
 }
-#treat-subtitle span {
-    color: #FF69B4;
     font-weight: bold;
 }
 .content-box {
-    background: rgba(255,255,255,0.9);
     border-radius: 15px;
-    border: 2px solid #FFB6C1;
-    padding: 1rem;
 }
-.analyze-button {
-    background: linear-gradient(45deg, #FF69B4, #87CEEB) !important;
-    border: none !important;
-    border-radius: 25px !important;
-    color: white !important;
-    font-family: 'Nunito', sans-serif !important;
-    font-weight: bold !important;
-    padding: 0.8rem 2rem !important;
-    transition: transform 0.2s !important;
 }
-.analyze-button:hover {
-    transform: translateY(-2px) !important;
 }
-.results-container {
-    background: rgba(255,255,255,0.9);
-    border-radius: 15px;
-    padding: 1.5rem;
-    margin-top: 1rem;
-    border: 2px solid #87CEEB;
 }
-#loading-bar {
-    height: 6px;
-    background: linear-gradient(90deg, #FF69B4, #87CEEB);
-    border-radius: 3px;
-    transition: width 0.3s ease;
 }
 """
-def analyze_with_loading(text):
-    # Simulate loading progress (you can integrate this with your actual analysis)
-    for i in range(100):
-        time.sleep(0.02)  # Simulate processing time
-        yield {"progress": i + 1}
-    # Perform the actual analysis
     result = analyze_content(text)
-    # Format the results
-    if result["detected_triggers"] == ["None"]:
-        triggers_text = "No triggers detected"
-    else:
-        triggers_text = ", ".join(result["detected_triggers"])
-    yield {
-        "progress": 100,
-        "result": f"""
-        <div class='results-container'>
-            <h3 style='color: #FF69B4; margin-bottom: 1rem;'>Analysis Results</h3>
-            <p><strong>Triggers Detected:</strong> {triggers_text}</p>
-            <p><strong>Confidence:</strong> {result['confidence']}</p>
-            <p><strong>Analysis Time:</strong> {result['analysis_timestamp']}</p>
-        </div>
-        """
-    }
-with gr.Blocks(css=css) as iface:
-    with gr.Column(elem_id="treat-container"):
         gr.HTML("""
-            <div id="treat-title">TREAT</div>
-            <div id="treat-subtitle">
-                <span>T</span>rigger <span>R</span>ecognition for
-                <span>E</span>njoyable and <span>A</span>ppropriate
-                <span>T</span>elevision
-            </div>
         """)
-        text_input = gr.Textbox(
-            label="Enter your content for analysis",
-            placeholder="Paste your script or content here...",
-            lines=8,
-            elem_classes=["content-box"]
-        )
-        analyze_btn = gr.Button(
-            "🍬 Analyze Content",
-            elem_classes=["analyze-button"]
-        )
-        progress = gr.Number(
-            value=0,
-            visible=False,
-            elem_id="progress-value"
         )
-        gr.HTML("""
-            <div style="width: 100%; height: 6px; background: #eee; border-radius: 3px; margin: 1rem 0;">
-                <div id="loading-bar" style="width: 0%"></div>
-            </div>
-        """)
-        output = gr.HTML()
-        # JavaScript for updating the loading bar
-        gr.HTML("""
-            <script>
-                function updateLoadingBar(progress) {
-                    document.getElementById('loading-bar').style.width = progress + '%';
-                }
-                // Watch for changes to the progress value
-                const observer = new MutationObserver((mutations) => {
-                    mutations.forEach((mutation) => {
-                        if (mutation.type === 'attributes' && mutation.attributeName === 'value') {
-                            const progress = document.getElementById('progress-value').value;
-                            updateLoadingBar(progress);
-                        }
-                    });
-                });
-                // Start observing the progress value element
-                observer.observe(document.getElementById('progress-value'), {
-                    attributes: true
-                });
-            </script>
-        """)
-        analyze_btn.click(
-            fn=analyze_with_loading,
-            inputs=[text_input],
-            outputs=[gr.State({"progress": 0, "result": ""}), output],
-            show_progress=False
         )
 if __name__ == "__main__":
     iface.launch()

+# gradio_app.py
 import gradio as gr
 from model.analyzer import analyze_content
+import time
+# Custom CSS for styling
+custom_css = """
+.treat-title {
+    text-align: center;
+    padding: 20px;
+    margin-bottom: 20px;
+    background: linear-gradient(135deg, #fce4ec 0%, #e3f2fd 100%);
+    border-radius: 15px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
 }
+.treat-title h1 {
+    font-size: 3em;
+    color: #d81b60;
+    margin-bottom: 10px;
     font-weight: bold;
 }
+.treat-title p {
+    font-size: 1.2em;
+    color: #5c6bc0;
 }
+.highlight {
+    color: #d81b60;
     font-weight: bold;
 }
 .content-box {
+    background: rgba(255, 255, 255, 0.9);
     border-radius: 15px;
+    padding: 20px;
+    margin: 20px 0;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
 }
+.results-box {
+    background: rgba(255, 255, 255, 0.9);
+    border-radius: 15px;
+    padding: 20px;
+    margin-top: 20px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
 }
+.gradio-container {
+    background: linear-gradient(135deg, #fce4ec 0%, #e3f2fd 100%);
 }
+.analyze-button {
+    background-color: #d81b60 !important;
+    color: white !important;
+    border-radius: 25px !important;
+    padding: 10px 20px !important;
+    font-size: 1.1em !important;
+    transition: transform 0.2s !important;
 }
+.analyze-button:hover {
+    transform: scale(1.05) !important;
 }
 """
+def analyze_with_loading(text, progress=gr.Progress()):
+    # Initialize progress
+    progress(0, desc="Starting analysis...")
+    # Simulate initial loading (model preparation)
+    for i in range(30):
+        time.sleep(0.1)  # Reduced sleep time for better UX
+        progress((i + 1) / 100)
+    # Perform actual analysis
+    progress(0.3, desc="Processing text...")
     result = analyze_content(text)
+    # Simulate final processing
+    for i in range(70, 100):
+        time.sleep(0.05)  # Reduced sleep time
+        progress((i + 1) / 100)
+    # Format the results for display
+    triggers = result["detected_triggers"]
+    if triggers == ["None"]:
+        return "No triggers detected in the content."
+    else:
+        trigger_list = "\n".join([f"• {trigger}" for trigger in triggers])
+        return f"Triggers Detected:\n{trigger_list}"
+with gr.Blocks(css=custom_css) as iface:
+    # Title section
+    with gr.Box(elem_classes="treat-title"):
         gr.HTML("""
+            <h1>TREAT</h1>
+            <p><span class="highlight">T</span>rigger
+               <span class="highlight">R</span>ecognition for
+               <span class="highlight">E</span>njoyable and
+               <span class="highlight">A</span>ppropriate
+               <span class="highlight">T</span>elevision</p>
         """)
+    # Content input section
+    with gr.Box(elem_classes="content-box"):
+        input_text = gr.Textbox(
+            label="Content to Analyze",
+            placeholder="Paste your content here...",
+            lines=8
         )
+    # Analysis button
+    analyze_btn = gr.Button(
+        "Analyze Content",
+        elem_classes="analyze-button"
+    )
+    # Results section
+    with gr.Box(elem_classes="results-box"):
+        output_text = gr.Textbox(
+            label="Analysis Results",
+            lines=5,
+            readonly=True
         )
+    # Set up the click event
+    analyze_btn.click(
+        fn=analyze_with_loading,
+        inputs=[input_text],
+        outputs=[output_text],
+        api_name="analyze"
+    )
 if __name__ == "__main__":
     iface.launch()

model/analyzer.py CHANGED Viewed

@@ -1,145 +1,146 @@
-# analyzer.py
-# model > analyzer.py
 import os
 from transformers import AutoTokenizer, AutoModelForCausalLM
 import torch
 from datetime import datetime
 import gradio as gr
-# Fetch the Hugging Face token from the environment variable (secrets)
-hf_token = os.getenv("HF_TOKEN")
-if not hf_token:
-    raise ValueError("HF_TOKEN environment variable is not set!")
-def analyze_script(script):
-    # Starting the script analysis
-    print("\n=== Starting Analysis ===")
-    print(f"Time: {datetime.now()}")  # Outputting the current timestamp
-    print("Loading model and tokenizer...")
-    try:
-        # Load the tokenizer and model, selecting the appropriate device (CPU or CUDA)
-        tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B", use_fast=True)
-        device = "cuda" if torch.cuda.is_available() else "cpu"  # Use CUDA if available, else use CPU
-        print(f"Using device: {device}")
-        # Load model with token authentication
-        model = AutoModelForCausalLM.from_pretrained(
-            "meta-llama/Llama-3.2-1B",
-            token=hf_token,  # Pass the token to authenticate
-            torch_dtype=torch.float16 if device == "cuda" else torch.float32,  # Use 16-bit precision for CUDA, 32-bit for CPU
-            device_map="auto"  # Automatically map model to available device
-        )
-        print("Model loaded successfully")
-    except Exception as e:
-        print(f"An error occurred: {e}")
-        return []
-    # Define trigger categories with their descriptions
-    trigger_categories = {
-        "Violence": {
-            "mapped_name": "Violence",
-            "description": (
-                "Any act involving physical force or aggression intended to cause harm, injury, or death to a person, animal, or object. "
-                "Includes direct physical confrontations (e.g., fights, beatings, or assaults), implied violence (e.g., very graphical threats or descriptions of injuries), "
-                "or large-scale events like wars, riots, or violent protests."
-            )
-        },
-        "Death": {
-            "mapped_name": "Death References",
-            "description": (
-                "Any mention, implication, or depiction of the loss of life, including direct deaths of characters, including mentions of deceased individuals, "
-                "or abstract references to mortality (e.g., 'facing the end' or 'gone forever'). This also covers depictions of funerals, mourning, "
-                "grieving, or any dialogue that centers around death, do not take metaphors into context that don't actually lead to death."
-            )
-        },
-        "Substance Use": {
-            "mapped_name": "Substance Use",
-            "description": (
-                "Any explicit or implied reference to the consumption, misuse, or abuse of drugs, alcohol, or other intoxicating substances. "
-                "Includes scenes of drinking, smoking, or drug use, whether recreational or addictive. May also cover references to withdrawal symptoms, "
-                "rehabilitation, or substance-related paraphernalia (e.g., needles, bottles, pipes)."
-            )
-        },
-        "Gore": {
-            "mapped_name": "Gore",
-            "description": (
-                "Extremely detailed and graphic depictions of highly severe physical injuries, mutilation, or extreme bodily harm, often accompanied by descriptions of heavy blood, exposed organs, "
-                "or dismemberment. This includes war scenes with severe casualties, horror scenarios involving grotesque creatures, or medical procedures depicted with excessive detail."
-            )
-        },
-        "Vomit": {
-            "mapped_name": "Vomit",
-            "description": (
-                "Any reference to the act of vomiting, whether directly described, implied, or depicted in detail. This includes sounds or visual descriptions of the act, "
-                "mentions of nausea leading to vomiting, or its aftermath (e.g., the presence of vomit, cleaning it up, or characters reacting to it)."
-            )
-        },
-        "Sexual Content": {
-            "mapped_name": "Sexual Content",
-            "description": (
-                "Any depiction or mention of sexual activity, intimacy, or sexual behavior, ranging from implied scenes to explicit descriptions. "
-                "This includes romantic encounters, physical descriptions of characters in a sexual context, sexual dialogue, or references to sexual themes (e.g., harassment, innuendos)."
-            )
-        },
-        "Sexual Abuse": {
-            "mapped_name": "Sexual Abuse",
-            "description": (
-                "Any form of non-consensual sexual act, behavior, or interaction, involving coercion, manipulation, or physical force. "
-                "This includes incidents of sexual assault, molestation, exploitation, harassment, and any acts where an individual is subjected to sexual acts against their will or without their consent. "
-                "It also covers discussions or depictions of the aftermath of such abuse, such as trauma, emotional distress, legal proceedings, or therapy. "
-                "References to inappropriate sexual advances, groping, or any other form of sexual misconduct are also included, as well as the psychological and emotional impact on survivors. "
-                "Scenes where individuals are placed in sexually compromising situations, even if not directly acted upon, may also fall under this category."
-            )
-        },
-        "Self-Harm": {
-            "mapped_name": "Self-Harm",
-            "description": (
-                "Any mention or depiction of behaviors where an individual intentionally causes harm to themselves. This includes cutting, burning, or other forms of physical injury, "
-                "as well as suicidal ideation, suicide attempts, or discussions of self-destructive thoughts and actions. References to scars, bruises, or other lasting signs of self-harm are also included."
-            )
-        },
-        "Gun Use": {
-            "mapped_name": "Gun Use",
-            "description": (
-                "Any explicit or implied mention of firearms being handled, fired, or used in a threatening manner. This includes scenes of gun violence, references to shootings, "
-                "gun-related accidents, or the presence of firearms in a tense or dangerous context (e.g., holstered weapons during an argument)."
-            )
-        },
-        "Animal Cruelty": {
-            "mapped_name": "Animal Cruelty",
-            "description": (
-                "Any act of harm, abuse, or neglect toward animals, whether intentional or accidental. This includes physical abuse (e.g., hitting, injuring, or killing animals), "
-                "mental or emotional mistreatment (e.g., starvation, isolation), and scenes where animals are subjected to pain or suffering for human entertainment or experimentation."
-            )
-        },
-        "Mental Health Issues": {
-            "mapped_name": "Mental Health Issues",
-            "description": (
-                "Any reference to mental health struggles, disorders, or psychological distress. This includes mentions of depression, anxiety, PTSD, bipolar disorder, schizophrenia, "
-                "or other conditions. Scenes depicting therapy sessions, psychiatric treatment, or coping mechanisms (e.g., medication, journaling) are also included. May cover subtle hints "
-                "like a character expressing feelings of worthlessness, hopelessness, or detachment from reality."
-            )
         }
-    }
-    print("\nProcessing text...")  # Output indicating the text is being processed
-    chunk_size = 256  # Set the chunk size for text processing
-    overlap = 15  # Overlap between chunks for context preservation
-    script_chunks = [script[i:i + chunk_size] for i in range(0, len(script), chunk_size - overlap)]
-    identified_triggers = {}
-    for chunk_idx, chunk in enumerate(script_chunks, 1):
-        print(f"\n--- Processing Chunk {chunk_idx}/{len(script_chunks)} ---")
-        for category, info in trigger_categories.items():
             mapped_name = info["mapped_name"]
             description = info["description"]
-            print(f"\nAnalyzing for {mapped_name}...")
             prompt = f"""
             Check this text for any indication of {mapped_name} ({description}).
             Be sensitive to subtle references or implications, make sure the text is not metaphorical.
@@ -148,81 +149,107 @@ def analyze_script(script):
             Answer:
             """
-            print("Sending prompt to model...")  # Indicate that prompt is being sent to the model
-            inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)  # Tokenize the prompt
-            inputs = {k: v.to(device) for k, v in inputs.items()}  # Send inputs to the chosen device
-            with torch.no_grad():  # Disable gradient calculation for inference
-                print("Generating response...")  # Indicate that the model is generating a response
-                outputs = model.generate(
-                    **inputs,
-                    max_new_tokens=3,  # Limit response length
-                    do_sample=True,  # Enable sampling for more diverse output
-                    temperature=0.7,  # Control randomness of the output
-                    top_p=0.8,  # Use nucleus sampling
-                    pad_token_id=tokenizer.eos_token_id  # Pad token ID
-                )
-            response_text = tokenizer.decode(outputs[0], skip_special_tokens=True).strip().upper()  # Decode and format the response
-            first_word = response_text.split("\n")[-1].split()[0] if response_text else "NO"  # Get the first word of the response
-            print(f"Model response for {mapped_name}: {first_word}")
-            # Update identified triggers based on model response
-            if first_word == "YES":
-                print(f"Detected {mapped_name} in this chunk!")  # Trigger detected
-                identified_triggers[mapped_name] = identified_triggers.get(mapped_name, 0) + 1
-            elif first_word == "MAYBE":
-                print(f"Possible {mapped_name} detected, marking for further review.")  # Possible trigger detected
-                identified_triggers[mapped_name] = identified_triggers.get(mapped_name, 0) + 0.5
-            else:
-                print(f"No {mapped_name} detected in this chunk.")  # No trigger detected
-    print("\n=== Analysis Complete ===")  # Indicate that analysis is complete
-    final_triggers = []  # List to store final triggers
-    # Filter and output the final trigger results
-    for mapped_name, count in identified_triggers.items():
-        if count > 0.5:
-            final_triggers.append(mapped_name)
-        print(f"- {mapped_name}: found in {count} chunks")
-    if not final_triggers:
-        final_triggers = ["None"]
-    return final_triggers
-# Define the Gradio interface
-def analyze_content(script):
-    # Perform the analysis on the input script using the analyze_script function
-    triggers = analyze_script(script)
-    # Define the result based on the triggers found
-    if isinstance(triggers, list) and triggers != ["None"]:
         result = {
             "detected_triggers": triggers,
-            "confidence": "High - Content detected",
-            "model": "Llama-3.2-1B",
-            "analysis_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        }
-    else:
-        result = {
-            "detected_triggers": ["None"],
-            "confidence": "High - No concerning content detected",
             "model": "Llama-3.2-1B",
             "analysis_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         }
-    print("\nFinal Result Dictionary:", result)
-    return result
-# Create and launch the Gradio interface
-iface = gr.Interface(
-    fn=analyze_content,
-    inputs=gr.Textbox(lines=8, label="Input Text"),
-    outputs=gr.JSON(),
-    title="Content Analysis",
-    description="Analyze text content for sensitive topics"
-)
 if __name__ == "__main__":
     iface.launch()

 import os
 from transformers import AutoTokenizer, AutoModelForCausalLM
 import torch
 from datetime import datetime
 import gradio as gr
+from typing import Dict, List, Union, Optional
+import logging
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+class ContentAnalyzer:
+    def __init__(self):
+        self.hf_token = os.getenv("HF_TOKEN")
+        if not self.hf_token:
+            raise ValueError("HF_TOKEN environment variable is not set!")
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = None
+        self.tokenizer = None
+        self.trigger_categories = self._init_trigger_categories()
+    def _init_trigger_categories(self) -> Dict:
+        """Initialize trigger categories with their descriptions."""
+        return {
+            "Violence": {
+                "mapped_name": "Violence",
+                "description": (
+                    "Any act involving physical force or aggression intended to cause harm, injury, or death to a person, animal, or object. "
+                    "Includes direct physical confrontations, implied violence, or large-scale events like wars, riots, or violent protests."
+                )
+            },
+            "Death": {
+                "mapped_name": "Death References",
+                "description": (
+                    "Any mention, implication, or depiction of the loss of life, including direct deaths of characters, mentions of deceased individuals, "
+                    "or abstract references to mortality. This covers depictions of funerals, mourning, or death-centered dialogue."
+                )
+            },
+            "Substance Use": {
+                "mapped_name": "Substance Use",
+                "description": (
+                    "Any explicit or implied reference to the consumption, misuse, or abuse of drugs, alcohol, or other intoxicating substances. "
+                    "Includes scenes of drinking, smoking, drug use, withdrawal symptoms, or rehabilitation."
+                )
+            },
+            "Gore": {
+                "mapped_name": "Gore",
+                "description": (
+                    "Extremely detailed and graphic depictions of severe physical injuries, mutilation, or extreme bodily harm, including heavy blood, "
+                    "exposed organs, or dismemberment."
+                )
+            },
+            "Vomit": {
+                "mapped_name": "Vomit",
+                "description": "Any reference to the act of vomiting, whether directly described, implied, or depicted in detail."
+            },
+            "Sexual Content": {
+                "mapped_name": "Sexual Content",
+                "description": (
+                    "Any depiction or mention of sexual activity, intimacy, or sexual behavior, from implied scenes to explicit descriptions."
+                )
+            },
+            "Sexual Abuse": {
+                "mapped_name": "Sexual Abuse",
+                "description": (
+                    "Any form of non-consensual sexual act, behavior, or interaction, involving coercion, manipulation, or physical force."
+                )
+            },
+            "Self-Harm": {
+                "mapped_name": "Self-Harm",
+                "description": (
+                    "Any mention or depiction of behaviors where an individual intentionally causes harm to themselves, including suicidal thoughts."
+                )
+            },
+            "Gun Use": {
+                "mapped_name": "Gun Use",
+                "description": (
+                    "Any explicit or implied mention of firearms being handled, fired, or used in a threatening manner."
+                )
+            },
+            "Animal Cruelty": {
+                "mapped_name": "Animal Cruelty",
+                "description": (
+                    "Any act of harm, abuse, or neglect toward animals, whether intentional or accidental."
+                )
+            },
+            "Mental Health Issues": {
+                "mapped_name": "Mental Health Issues",
+                "description": (
+                    "Any reference to mental health struggles, disorders, or psychological distress, including therapy and treatment."
+                )
+            }
         }
+    async def load_model(self, progress=None) -> None:
+        """Load the model and tokenizer with progress updates."""
+        try:
+            if progress:
+                progress(0.1, "Loading tokenizer...")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                "meta-llama/Llama-3.2-1B",
+                use_fast=True
+            )
+            if progress:
+                progress(0.3, "Loading model...")
+            self.model = AutoModelForCausalLM.from_pretrained(
+                "meta-llama/Llama-3.2-1B",
+                token=self.hf_token,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto"
+            )
+            if progress:
+                progress(0.5, "Model loaded successfully")
+            logger.info(f"Model loaded successfully on {self.device}")
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}")
+            raise
+    def _chunk_text(self, text: str, chunk_size: int = 256, overlap: int = 15) -> List[str]:
+        """Split text into overlapping chunks for processing."""
+        return [text[i:i + chunk_size] for i in range(0, len(text), chunk_size - overlap)]
+    async def analyze_chunk(
+        self,
+        chunk: str,
+        progress: Optional[gr.Progress] = None,
+        current_progress: float = 0,
+        progress_step: float = 0
+    ) -> Dict[str, float]:
+        """Analyze a single chunk of text for triggers."""
+        chunk_triggers = {}
+        for category, info in self.trigger_categories.items():
             mapped_name = info["mapped_name"]
             description = info["description"]
             prompt = f"""
             Check this text for any indication of {mapped_name} ({description}).
             Be sensitive to subtle references or implications, make sure the text is not metaphorical.
             Answer:
             """
+            try:
+                inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+                inputs = {k: v.to(self.device) for k, v in inputs.items()}
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        **inputs,
+                        max_new_tokens=3,
+                        do_sample=True,
+                        temperature=0.7,
+                        top_p=0.8,
+                        pad_token_id=self.tokenizer.eos_token_id
+                    )
+                response_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True).strip().upper()
+                first_word = response_text.split("\n")[-1].split()[0] if response_text else "NO"
+                if first_word == "YES":
+                    chunk_triggers[mapped_name] = chunk_triggers.get(mapped_name, 0) + 1
+                elif first_word == "MAYBE":
+                    chunk_triggers[mapped_name] = chunk_triggers.get(mapped_name, 0) + 0.5
+                if progress:
+                    current_progress += progress_step
+                    progress(min(current_progress, 0.9), f"Analyzing {mapped_name}...")
+            except Exception as e:
+                logger.error(f"Error analyzing chunk for {mapped_name}: {str(e)}")
+        return chunk_triggers
+    async def analyze_script(self, script: str, progress: Optional[gr.Progress] = None) -> List[str]:
+        """Analyze the entire script for triggers with progress updates."""
+        if not self.model or not self.tokenizer:
+            await self.load_model(progress)
+        chunks = self._chunk_text(script)
+        identified_triggers = {}
+        progress_step = 0.4 / (len(chunks) * len(self.trigger_categories))
+        current_progress = 0.5  # Starting after model loading
+        for chunk_idx, chunk in enumerate(chunks, 1):
+            chunk_triggers = await self.analyze_chunk(
+                chunk,
+                progress,
+                current_progress,
+                progress_step
+            )
+            for trigger, count in chunk_triggers.items():
+                identified_triggers[trigger] = identified_triggers.get(trigger, 0) + count
+        if progress:
+            progress(0.95, "Finalizing results...")
+        final_triggers = [
+            trigger for trigger, count in identified_triggers.items()
+            if count > 0.5
+        ]
+        return final_triggers if final_triggers else ["None"]
+async def analyze_content(
+    script: str,
+    progress: Optional[gr.Progress] = None
+) -> Dict[str, Union[List[str], str]]:
+    """Main analysis function for the Gradio interface."""
+    analyzer = ContentAnalyzer()
+    try:
+        triggers = await analyzer.analyze_script(script, progress)
+        if progress:
+            progress(1.0, "Analysis complete!")
         result = {
             "detected_triggers": triggers,
+            "confidence": "High - Content detected" if triggers != ["None"] else "High - No concerning content detected",
             "model": "Llama-3.2-1B",
             "analysis_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         }
+        return result
+    except Exception as e:
+        logger.error(f"Analysis error: {str(e)}")
+        return {
+            "detected_triggers": ["Error occurred during analysis"],
+            "confidence": "Error",
+            "model": "Llama-3.2-1B",
+            "analysis_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "error": str(e)
+        }
 if __name__ == "__main__":
+    # This section is mainly for testing the analyzer directly
+    iface = gr.Interface(
+        fn=analyze_content,
+        inputs=gr.Textbox(lines=8, label="Input Text"),
+        outputs=gr.JSON(),
+        title="Content Analysis",
+        description="Analyze text content for sensitive topics"
+    )
     iface.launch()