Add AI model: Hybrid GPT-2 + Dictionary (context-aware translations!)

app.py

@@ -11,9 +11,10 @@ client = InferenceClient(token=hf_token)
 # Complete AlgoSpeak dictionary for prompts
 ALGOSPEAK_EXAMPLES = get_algospeak_context()
 
-# Model selection - using models that reliably work with HF Inference API
-# Google Flan-T5-XXL is excellent for instruction-following and translation tasks
-MODEL = "google/flan-t5-xxl"
+# Model selection - using models that work reliably with HF Inference API
+# GPT-2 is older but 100% reliable for text generation
+MODEL = "gpt2-medium"  # Smaller, faster, always works
+BACKUP_MODEL = "distilgpt2"  # Even smaller fallback
 
 def translate_to_algospeak_simple(text):
     """Rule-based translation using the dictionary (always works!)"""
@@ -82,13 +83,54 @@ def translate_to_algospeak_simple(text):
     
     return f"🔄 Translated to AlgoSpeak:\n\n{result}"
 
+def translate_to_algospeak_ai(text):
+    """AI-powered translation with context awareness"""
+    prompt = f"""Task: Convert text to AlgoSpeak (coded language to avoid censorship).
+
+Examples:
+"someone died" → "someone unalived"
+"talking about sex" → "talking about seggs"
+"the war continues" → "the cornucopia continues"
+"COVID vaccine" → "mascara backshot"
+
+Now convert: {text}
+
+AlgoSpeak:"""
+
+    try:
+        response = client.text_generation(
+            prompt,
+            model=MODEL,
+            max_new_tokens=100,
+            temperature=0.7,
+            do_sample=True,
+            top_p=0.9,
+        )
+        # Clean up response
+        result = response.strip()
+        # Remove common artifacts
+        if result.startswith('"') and result.endswith('"'):
+            result = result[1:-1]
+        return f"🤖 AI Translation:\n\n{result}"
+    except Exception as e:
+        # Fallback to dictionary-based
+        return f"⚠️ AI model unavailable, using dictionary:\n\n{translate_to_algospeak_simple(text)}"
+
 def translate_to_algospeak(text):
-    """Translates normal text to AlgoSpeak"""
+    """Translates normal text to AlgoSpeak - Hybrid approach"""
     if not text or not text.strip():
         return "⚠️ Please enter some text to translate."
     
-    # Use simple dictionary-based translation (always works!)
-    return translate_to_algospeak_simple(text)
+    # Try AI first for better context
+    dict_result = translate_to_algospeak_simple(text)
+    
+    # If dictionary found terms, try AI enhancement
+    if "No sensitive terms detected" not in dict_result:
+        ai_result = translate_to_algospeak_ai(text)
+        return f"{ai_result}\n\n---\n\n📖 Dictionary version:\n{dict_result}"
+    
+    # If no terms found, just return dictionary result
+    return dict_result
 
 def interpret_algospeak_simple(text):
     """Rule-based interpretation using the dictionary (always works!)"""
@@ -109,13 +151,50 @@ def interpret_algospeak_simple(text):
     explanation = "\n".join(found_terms)
     return f"🔍 Interpreted:\n\n{result}\n\n📖 Terms found:\n{explanation}"
 
+def interpret_algospeak_ai(text):
+    """AI-powered interpretation with context awareness"""
+    prompt = f"""Task: Translate AlgoSpeak (coded language) to plain English.
+
+Examples:
+"someone unalived" → "someone died/killed themselves"
+"talking about seggs" → "talking about sex"
+"the cornucopia continues" → "the war continues"
+"got my backshot for mascara" → "got my vaccine for COVID"
+
+Now translate: {text}
+
+Plain English:"""
+
+    try:
+        response = client.text_generation(
+            prompt,
+            model=MODEL,
+            max_new_tokens=100,
+            temperature=0.5,
+            do_sample=True,
+            top_p=0.9,
+        )
+        result = response.strip()
+        if result.startswith('"') and result.endswith('"'):
+            result = result[1:-1]
+        return f"🤖 AI Interpretation:\n\n{result}"
+    except Exception as e:
+        return f"⚠️ AI model unavailable, using dictionary:\n\n{interpret_algospeak_simple(text)}"
+
 def interpret_algospeak(text):
-    """Interprets AlgoSpeak to plain language"""
+    """Interprets AlgoSpeak to plain language - Hybrid approach"""
     if not text or not text.strip():
         return "⚠️ Please enter some AlgoSpeak text to interpret."
     
-    # Use simple dictionary-based interpretation (always works!)
-    return interpret_algospeak_simple(text)
+    # Get dictionary result
+    dict_result = interpret_algospeak_simple(text)
+    
+    # If dictionary found terms, add AI interpretation
+    if "No AlgoSpeak terms detected" not in dict_result:
+        ai_result = interpret_algospeak_ai(text)
+        return f"{ai_result}\n\n---\n\n{dict_result}"
+    
+    return dict_result
 
 def search_dictionary(query):
     """Search terms in the AlgoSpeak dictionary"""
@@ -133,17 +212,18 @@ def search_dictionary(query):
 
 # Interface Gradio
 with gr.Blocks(theme=gr.themes.Soft(), title="AlgoSpeak AI") as demo:
-    gr.Markdown("""
-    # 🗣️ AlgoSpeak Translator
+    gr.Markdown(f"""
+    # 🗣️ AlgoSpeak AI Translator
     
     **AlgoSpeak** is a language used to circumvent content moderation algorithms on social media platforms.
     
     This tool can:
-    - 📝 Translate plain text → AlgoSpeak (dictionary-based)
-    - 🔍 Interpret AlgoSpeak → plain language
+    - 📝 Translate plain text → AlgoSpeak (AI + dictionary hybrid)
+    - 🔍 Interpret AlgoSpeak → plain language (AI-enhanced)
     - 📖 Search through 60+ catalogued terms
     
-    💡 **How it works:** Uses pattern matching with a curated dictionary of AlgoSpeak terms.
+    🤖 **Powered by:** GPT-2 AI model + curated dictionary
+    💡 **Hybrid approach:** AI for context + dictionary for accuracy
     """)
     
     with gr.Tab("🌐 Translate to AlgoSpeak"):