adv humanizer

app.py

@@ -1,120 +1,204 @@
-# For Hugging Face Spaces - this is the main app file with fallback dependencies
+# Production-grade AI Text Humanizer for Hugging Face Spaces
+# All advanced features enabled
+
 import gradio as gr
 import time
 import os
+import sys
 
-# Import our robust humanizer that handles dependency issues
-from text_humanizer import AITextHumanizer
+# Import our production humanizer
+from text_humanizer_production import ProductionAITextHumanizer
 
-# Initialize the humanizer
-print("🚀 Loading AI Text Humanizer for Hugging Face Spaces...")
-try:
-    humanizer = AITextHumanizer()
-    print("✅ Humanizer loaded successfully!")
-except Exception as e:
-    print(f"❌ Error loading humanizer: {e}")
-    humanizer = None
+# Global variables
+humanizer = None
+initialization_status = {}
 
-def humanize_text_hf(text, style, intensity):
+def initialize_humanizer():
+    """Initialize the production humanizer with status tracking"""
+    global humanizer, initialization_status
+    
+    print("🏭 Initializing Production AI Text Humanizer for Hugging Face Spaces...")
+    
+    try:
+        # Enable HF Spaces optimizations
+        humanizer = ProductionAITextHumanizer(
+            enable_gpu=True,  # HF Spaces may have GPU
+            model_cache_dir=os.environ.get('HF_HOME', '/tmp/huggingface_cache')
+        )
+        
+        initialization_status = {
+            "humanizer_loaded": True,
+            "advanced_similarity": humanizer.similarity_model is not None,
+            "ai_paraphrasing": humanizer.paraphraser is not None,
+            "tfidf_fallback": humanizer.tfidf_vectorizer is not None,
+            "total_features": 6,
+            "enabled_features": sum([
+                bool(humanizer.similarity_model),
+                bool(humanizer.paraphraser), 
+                bool(humanizer.tfidf_vectorizer),
+                True,  # Word mappings
+                True,  # Contractions
+                True   # Basic processing
+            ])
+        }
+        
+        print("✅ Production humanizer initialized successfully!")
+        print(f"🎯 Feature completeness: {(initialization_status['enabled_features']/initialization_status['total_features'])*100:.1f}%")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error initializing humanizer: {e}")
+        initialization_status = {"error": str(e), "humanizer_loaded": False}
+        return False
+
+def humanize_text_hf(text, style, intensity, show_details=False):
     """
-    Hugging Face Spaces interface function for text humanization
+    Hugging Face Spaces interface for production humanization
     """
     if not text.strip():
-        return "⚠️ Please enter some text to humanize.", "", 0.0, "No changes made", 0.0
+        return "⚠️ Please enter some text to humanize.", "", ""
     
     if humanizer is None:
-        return "❌ Error: Humanizer not loaded properly.", "", 0.0, "System error", 0.0
+        return "❌ Error: Humanizer not loaded properly. Please refresh the page.", "", ""
     
     try:
         start_time = time.time()
         
-        # Humanize the text
-        result = humanizer.humanize_text(
+        # Use production humanization method
+        result = humanizer.humanize_text_production(
             text=text,
             style=style.lower(),
-            intensity=intensity
+            intensity=intensity,
+            quality_threshold=0.75
         )
         
         processing_time = (time.time() - start_time) * 1000
         
-        changes_text = ", ".join(result["changes_made"]) if result["changes_made"] else "No significant changes made"
+        # Format detailed stats
+        details = f"""**🎯 Production Results:**
+- **Quality Score:** {result['quality_score']:.3f} (Higher = Better)
+- **Similarity Score:** {result['similarity_score']:.3f} (Meaning Preservation)
+- **Processing Time:** {processing_time:.1f}ms
+- **Style:** {result['style'].title()}
+- **Intensity:** {result['intensity']}
+- **Length Change:** {result['length_change']} characters
+- **Word Count Change:** {result['word_count_change']} words
+
+**🔧 Features Used:**
+{', '.join(result['feature_usage'].keys()) if result['feature_usage'] else 'Basic transformations only'}
+
+**📝 Transformations Applied:**
+{chr(10).join([f'• {change}' for change in result['changes_made']]) if result['changes_made'] else '• No significant changes needed'}"""
         
-        return (
-            result["humanized_text"],
-            f"**📊 Processing Results:**\n- **Similarity Score:** {result['similarity_score']:.3f}\n- **Processing Time:** {processing_time:.1f}ms\n- **Style:** {result['style'].title()}\n- **Intensity:** {result['intensity']}\n\n**🔄 Changes Made:** {changes_text}",
-            result["similarity_score"],
-            changes_text,
-            processing_time
-        )
+        # Show feature status in details
+        feature_status = f"""
+**⚡ Advanced Features Status:**
+- Advanced Similarity: {'✅ ENABLED' if initialization_status.get('advanced_similarity') else '❌ DISABLED'}
+- AI Paraphrasing: {'✅ ENABLED' if initialization_status.get('ai_paraphrasing') else '❌ DISABLED'}
+- Quality Control: ✅ ENABLED
+- Feature Completeness: {(initialization_status.get('enabled_features', 3)/initialization_status.get('total_features', 6))*100:.1f}%"""
+        
+        full_details = details + feature_status if show_details else details
+        
+        return result['humanized_text'], full_details, f"✅ Success - Quality: {result['quality_score']:.3f}"
         
     except Exception as e:
-        return f"❌ Error processing text: {str(e)}", "", 0.0, "Processing error", 0.0
+        error_msg = f"❌ Error processing text: {str(e)}"
+        return error_msg, "", "❌ Processing failed"
+
+def get_feature_status():
+    """Get current feature status for display"""
+    if not initialization_status.get('humanizer_loaded'):
+        return "❌ Humanizer not loaded", "red"
+    
+    enabled = initialization_status.get('enabled_features', 0)
+    total = initialization_status.get('total_features', 6)
+    completeness = (enabled / total) * 100
+    
+    if completeness >= 90:
+        return f"🎉 Production Ready ({completeness:.0f}%)", "green"
+    elif completeness >= 70:
+        return f"⚠️ Most Features Enabled ({completeness:.0f}%)", "orange"
+    else:
+        return f"❌ Limited Features ({completeness:.0f}%)", "red"
+
+# Initialize the humanizer on startup
+initialization_success = initialize_humanizer()
 
-# Create the Hugging Face Spaces interface
+# Create the Gradio interface
 with gr.Blocks(
-    title="🤖➡️👤 AI Text Humanizer",
+    title="🤖➡️👤 AI Text Humanizer Pro",
     theme=gr.themes.Soft(),
     css="""
         .main-header {
             text-align: center;
-            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
             color: white;
-            padding: 20px;
-            border-radius: 10px;
-            margin-bottom: 20px;
+            padding: 25px;
+            border-radius: 15px;
+            margin-bottom: 25px;
+            box-shadow: 0 4px 15px rgba(0,0,0,0.1);
         }
+        .feature-status {
+            text-align: center;
+            padding: 10px;
+            border-radius: 8px;
+            margin: 10px 0;
+            font-weight: bold;
+        }
+        .status-green { background-color: #d4edda; border: 1px solid #c3e6cb; color: #155724; }
+        .status-orange { background-color: #fff3cd; border: 1px solid #ffeaa7; color: #856404; }
+        .status-red { background-color: #f8d7da; border: 1px solid #f5c6cb; color: #721c24; }
         .stats-box {
+            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+            padding: 20px;
+            border-radius: 12px;
+            border-left: 5px solid #667eea;
+            margin: 15px 0;
+        }
+        .example-box {
             background: #f8f9fa;
             padding: 15px;
             border-radius: 8px;
-            border-left: 4px solid #667eea;
-        }
-        .warning-box {
-            background: #fff3cd;
-            border: 1px solid #ffeaa7;
-            color: #856404;
-            padding: 10px;
-            border-radius: 5px;
+            border: 1px solid #dee2e6;
             margin: 10px 0;
         }
     """
-) as iface:
+) as demo:
     
-    gr.HTML("""
+    gr.HTML(f"""
         <div class="main-header">
-            <h1>🤖➡️👤 AI Text Humanizer</h1>
-            <p>Transform AI-generated text to sound more natural and human-like</p>
-            <p><em>Powered by advanced NLP techniques - Works even with limited dependencies!</em></p>
+            <h1>🤖➡️👤 AI Text Humanizer Pro</h1>
+            <p>Production-Grade AI Text Humanization with Advanced Features</p>
+            <p><em>Transform AI-generated text to sound naturally human</em></p>
         </div>
     """)
     
-    # Check model availability and show warnings
-    if humanizer:
-        from text_humanizer import SENTENCE_TRANSFORMERS_AVAILABLE, TRANSFORMERS_AVAILABLE, SKLEARN_AVAILABLE
-        
-        if not SENTENCE_TRANSFORMERS_AVAILABLE:
-            gr.HTML("""
-                <div class="warning-box">
-                    ⚠️ <strong>Note:</strong> Advanced similarity models not available. Using fallback similarity calculation.
-                </div>
-            """)
-        
-        if not TRANSFORMERS_AVAILABLE:
-            gr.HTML("""
-                <div class="warning-box">
-                    ⚠️ <strong>Note:</strong> Paraphrasing models not available. Advanced paraphrasing disabled.
-                </div>
-            """)
+    # Feature status indicator
+    if initialization_success:
+        status_text, status_color = get_feature_status()
+        gr.HTML(f"""
+            <div class="feature-status status-{status_color}">
+                {status_text}
+            </div>
+        """)
+    else:
+        gr.HTML(f"""
+            <div class="feature-status status-red">
+                ❌ Initialization Failed - Please refresh the page
+            </div>
+        """)
     
-    with gr.Tab("🎯 Humanize Text"):
+    with gr.Tab("🚀 Humanize Text"):
         with gr.Row():
             with gr.Column(scale=1):
                 gr.HTML("<h3>📝 Input</h3>")
                 
                 input_text = gr.Textbox(
                     label="Text to Humanize",
-                    placeholder="Paste your AI-generated text here...\n\nExample: Furthermore, it is important to note that artificial intelligence systems demonstrate significant capabilities...",
-                    lines=10,
+                    placeholder="Paste your AI-generated text here...\n\nExample: Furthermore, it is important to note that artificial intelligence systems demonstrate significant capabilities in natural language processing tasks. Subsequently, these systems can analyze and generate text with remarkable accuracy.",
+                    lines=12,
                     max_lines=20
                 )
                 
@@ -122,148 +206,156 @@ with gr.Blocks(
                     style_dropdown = gr.Dropdown(
                         choices=["Natural", "Casual", "Conversational"],
                         value="Natural",
-                        label="🎨 Humanization Style"
+                        label="🎨 Humanization Style",
+                        info="Natural: Professional with human touch | Casual: Relaxed and clear | Conversational: Like talking to a friend"
                     )
                     
                     intensity_slider = gr.Slider(
                         minimum=0.1,
                         maximum=1.0,
-                        value=0.7,
+                        value=0.8,
                         step=0.1,
-                        label="⚡ Intensity Level"
+                        label="⚡ Intensity Level",
+                        info="How much to humanize (0.1 = subtle, 1.0 = maximum)"
                     )
                 
-                humanize_btn = gr.Button(
-                    "🚀 Humanize Text", 
-                    variant="primary",
-                    size="lg"
-                )
+                with gr.Row():
+                    humanize_btn = gr.Button(
+                        "🚀 Humanize Text", 
+                        variant="primary",
+                        size="lg"
+                    )
+                    
+                    details_checkbox = gr.Checkbox(
+                        label="📊 Show Advanced Details",
+                        value=True
+                    )
             
             with gr.Column(scale=1):
                 gr.HTML("<h3>✨ Output</h3>")
                 
                 output_text = gr.Textbox(
                     label="Humanized Text",
-                    lines=10,
+                    lines=12,
                     max_lines=20,
                     show_copy_button=True
                 )
                 
+                status_output = gr.Textbox(
+                    label="Status",
+                    lines=1,
+                    interactive=False
+                )
+                
                 stats_output = gr.Markdown(
-                    label="📊 Processing Statistics",
+                    label="📊 Detailed Analysis",
                     value="Results will appear here after processing..."
                 )
     
-    with gr.Tab("📊 Examples & Guide"):
-        gr.HTML("<h3>💡 Try These Examples</h3>")
+    with gr.Tab("📊 Examples & Features"):
+        gr.HTML("""
+            <div class="stats-box">
+                <h3>🎯 Advanced Production Features</h3>
+                <p>This production-grade humanizer includes:</p>
+            </div>
+        """)
+        
+        # Show current feature status
+        if initialization_success:
+            feature_list = f"""
+            <div class="example-box">
+                <h4>✅ Currently Enabled Features:</h4>
+                <ul>
+                    <li><strong>Advanced Semantic Similarity:</strong> {'✅ ENABLED' if initialization_status.get('advanced_similarity') else '❌ DISABLED'} - Uses sentence transformers for meaning preservation</li>
+                    <li><strong>AI Paraphrasing:</strong> {'✅ ENABLED' if initialization_status.get('ai_paraphrasing') else '❌ DISABLED'} - Google's FLAN-T5 for intelligent rewrites</li>
+                    <li><strong>Smart Word Replacement:</strong> ✅ ENABLED - 70+ formal→casual mappings</li>
+                    <li><strong>Natural Contractions:</strong> ✅ ENABLED - 37+ contraction patterns</li>
+                    <li><strong>AI Transition Removal:</strong> ✅ ENABLED - Removes robotic phrases</li>
+                    <li><strong>Quality Control:</strong> ✅ ENABLED - Automatic quality validation</li>
+                </ul>
+            </div>
+            """
+            gr.HTML(feature_list)
         
         # Examples
+        gr.HTML("<h3>💡 Try These Examples</h3>")
+        
         examples = gr.Examples(
             examples=[
                 [
                     "Furthermore, it is important to note that artificial intelligence systems demonstrate significant capabilities in natural language processing tasks. Subsequently, these systems can analyze and generate text with remarkable accuracy. Nevertheless, it is crucial to understand that human oversight remains essential for optimal performance.",
                     "Conversational",
-                    0.8
+                    0.8,
+                    True
                 ],
                 [
-                    "The implementation of this comprehensive solution will facilitate the optimization of business processes and operational workflows. Moreover, it will demonstrate substantial improvements in efficiency metrics while maintaining quality standards throughout the organization.",
+                    "The implementation of comprehensive methodologies will facilitate the optimization of business processes and operational workflows. Moreover, it will demonstrate substantial improvements in efficiency metrics while maintaining quality standards throughout the organization.",
                     "Natural", 
-                    0.6
+                    0.7,
+                    True
                 ],
                 [
-                    "In conclusion, the systematic analysis reveals that the proposed methodology demonstrates significant potential for enhancing performance indicators. Additionally, the structured approach ensures optimal resource utilization and maintains quality benchmarks.",
+                    "Subsequently, organizations must utilize systematic approaches to evaluate and implement technological solutions. Therefore, it is essential to establish comprehensive frameworks that demonstrate optimal performance and facilitate substantial improvements in operational efficiency.",
                     "Casual",
-                    0.7
+                    0.6,
+                    True
                 ],
                 [
-                    "It is essential to acknowledge that these technological advancements facilitate unprecedented opportunities for organizational growth. Therefore, stakeholders must implement comprehensive strategies to leverage these capabilities effectively.",
+                    "Moreover, the utilization of advanced algorithms enables organizations to obtain optimal results while maintaining sufficient quality standards. Additionally, these systems demonstrate remarkable capabilities in processing and analyzing substantial amounts of data with exceptional accuracy.",
                     "Conversational",
-                    0.9
+                    0.9,
+                    True
                 ]
             ],
-            inputs=[input_text, style_dropdown, intensity_slider],
-            outputs=[output_text, stats_output],
+            inputs=[input_text, style_dropdown, intensity_slider, details_checkbox],
+            outputs=[output_text, stats_output, status_output],
             fn=humanize_text_hf,
-            cache_examples=False
+            cache_examples=False,
+            label="Click any example to try it!"
         )
         
+        # Performance info
         gr.HTML("""
-            <div style="margin-top: 30px;">
-                <h3>🎯 How It Works</h3>
-                <div class="stats-box">
-                    <h4>🔧 Core Transformation Techniques:</h4>
-                    <ul>
-                        <li><strong>Smart Word Replacement:</strong> formal words → casual alternatives (utilize → use, demonstrate → show)</li>
-                        <li><strong>Contraction Addition:</strong> "do not" → "don't", "it is" → "it's"</li>
-                        <li><strong>AI Transition Removal:</strong> removes robotic phrases like "Furthermore," "Moreover,"</li>
-                        <li><strong>Sentence Restructuring:</strong> varies length and structure for natural flow</li>
-                        <li><strong>Natural Imperfections:</strong> adds human-like variations and casual touches</li>
-                        <li><strong>Context-Aware Processing:</strong> maintains meaning while improving readability</li>
-                    </ul>
-                </div>
-                
-                <div class="stats-box" style="margin-top: 15px;">
-                    <h4>🎨 Style Guide:</h4>
-                    <ul>
-                        <li><strong>Natural (0.5-0.7):</strong> Professional content with human touch - good for business writing</li>
-                        <li><strong>Casual (0.6-0.8):</strong> Blog posts, articles, informal content - relaxed but clear</li>
-                        <li><strong>Conversational (0.7-1.0):</strong> Social media, very informal text - like talking to a friend</li>
-                    </ul>
-                </div>
-                
-                <div class="stats-box" style="margin-top: 15px;">
-                    <h4>⚡ Performance & Features:</h4>
-                    <ul>
-                        <li><strong>Similarity Preservation:</strong> Maintains 85-95% semantic similarity to original</li>
-                        <li><strong>Fast Processing:</strong> ~500ms average response time</li>
-                        <li><strong>Robust Fallbacks:</strong> Works even when advanced models aren't available</li>
-                        <li><strong>Quality Control:</strong> Automatic quality checks prevent over-transformation</li>
-                        <li><strong>Dependency Resilient:</strong> Graceful degradation when libraries are missing</li>
-                    </ul>
-                </div>
-                
-                <div class="stats-box" style="margin-top: 15px;">
-                    <h4>🛠️ Technical Features:</h4>
-                    <ul>
-                        <li><strong>Multiple Similarity Methods:</strong> Advanced transformers → TF-IDF → word overlap fallbacks</li>
-                        <li><strong>Intelligent Processing:</strong> Context-aware transformations based on text type</li>
-                        <li><strong>Quality Assurance:</strong> Automatic reversion if similarity drops too low</li>
-                        <li><strong>Graceful Degradation:</strong> Works with minimal dependencies (just NLTK)</li>
-                    </ul>
-                </div>
+            <div class="stats-box">
+                <h3>⚡ Performance Specifications</h3>
+                <ul>
+                    <li><strong>Processing Speed:</strong> ~500ms average (first run includes model loading)</li>
+                    <li><strong>Quality Preservation:</strong> 85-95% semantic similarity maintained</li>
+                    <li><strong>Transformation Accuracy:</strong> Advanced NLP models ensure high-quality output</li>
+                    <li><strong>Production Ready:</strong> Comprehensive error handling and quality control</li>
+                </ul>
             </div>
         """)
         
-        if humanizer:
-            # Show current model status
-            from text_humanizer import SENTENCE_TRANSFORMERS_AVAILABLE, TRANSFORMERS_AVAILABLE, SKLEARN_AVAILABLE
-            
-            gr.HTML(f"""
-                <div class="stats-box" style="margin-top: 15px;">
-                    <h4>🔍 Current Model Status:</h4>
-                    <ul>
-                        <li><strong>Sentence Transformers:</strong> {'✅ Available (Advanced similarity)' if SENTENCE_TRANSFORMERS_AVAILABLE else '❌ Not available (Using fallback)'}</li>
-                        <li><strong>Transformers:</strong> {'✅ Available (Paraphrasing enabled)' if TRANSFORMERS_AVAILABLE else '❌ Not available (Paraphrasing disabled)'}</li>
-                        <li><strong>Scikit-learn:</strong> {'✅ Available (TF-IDF similarity)' if SKLEARN_AVAILABLE else '❌ Not available (Basic similarity)'}</li>
-                        <li><strong>NLTK:</strong> ✅ Available (Core text processing)</li>
-                    </ul>
-                    <p><em>The system automatically uses the best available methods and falls back gracefully when dependencies are missing.</em></p>
-                </div>
-            """)
+        # Usage guide
+        gr.HTML("""
+            <div class="example-box">
+                <h3>📋 Usage Guide</h3>
+                <ul>
+                    <li><strong>Natural (0.5-0.7):</strong> Best for professional content that needs human touch</li>
+                    <li><strong>Casual (0.6-0.8):</strong> Perfect for blog posts, articles, and informal content</li>
+                    <li><strong>Conversational (0.7-1.0):</strong> Ideal for social media and very informal text</li>
+                </ul>
+                <p><em>💡 Tip: Start with Natural style at 0.7 intensity for most use cases</em></p>
+            </div>
+        """)
     
     # Event handlers
     humanize_btn.click(
         fn=humanize_text_hf,
-        inputs=[input_text, style_dropdown, intensity_slider],
-        outputs=[output_text, stats_output]
+        inputs=[input_text, style_dropdown, intensity_slider, details_checkbox],
+        outputs=[output_text, stats_output, status_output]
     )
 
-# Launch for Hugging Face Spaces
+# Launch the interface
 if __name__ == "__main__":
-    print("🌐 Launching AI Text Humanizer on Hugging Face Spaces...")
-    iface.launch(
-        share=False,  # HF Spaces handles sharing
+    print("🌐 Launching Production AI Text Humanizer on Hugging Face Spaces...")
+    print(f"🎯 Initialization Status: {'✅ SUCCESS' if initialization_success else '❌ FAILED'}")
+    
+    demo.launch(
+        share=False,
         server_name="0.0.0.0",
         server_port=7860,
-        show_error=True
+        show_error=True,
+        show_api=False
     )

diagnose_and_fix.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Production Diagnostics and Quick Fix for AI Text Humanizer
+This script will identify exactly what's wrong and fix it
+"""
+
+import sys
+import subprocess
+import importlib
+import os
+
+def test_import(module_name, component=None):
+    """Test if a module/component can be imported"""
+    try:
+        if component:
+            module = importlib.import_module(module_name)
+            getattr(module, component)
+            return True, "OK"
+        else:
+            importlib.import_module(module_name)
+            return True, "OK"
+    except ImportError as e:
+        return False, f"ImportError: {str(e)}"
+    except AttributeError as e:
+        return False, f"AttributeError: {str(e)}"
+    except Exception as e:
+        return False, f"Error: {str(e)}"
+
+def run_pip_command(cmd):
+    """Run pip command safely"""
+    try:
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, check=True)
+        return True, result.stdout
+    except subprocess.CalledProcessError as e:
+        return False, e.stderr
+
+def main():
+    print("🔧 AI TEXT HUMANIZER - PRODUCTION DIAGNOSTICS & FIX")
+    print("=" * 60)
+    print("This will diagnose and fix your advanced model issues\n")
+    
+    # Test current imports
+    print("📋 CURRENT STATUS:")
+    print("-" * 20)
+    
+    tests = [
+        ("sentence_transformers", "SentenceTransformer"),
+        ("transformers", "pipeline"),
+        ("torch", None),
+        ("sklearn", None),
+        ("nltk", None),
+        ("gradio", None)
+    ]
+    
+    results = {}
+    for module, component in tests:
+        success, message = test_import(module, component)
+        status = "✅ WORKING" if success else "❌ FAILED"
+        print(f"{module}: {status}")
+        if not success:
+            print(f"   Error: {message}")
+        results[module] = success
+    
+    # Check specific model loading
+    print(f"\n🤖 TESTING MODEL LOADING:")
+    print("-" * 30)
+    
+    if results.get('sentence_transformers'):
+        try:
+            print("🔄 Testing sentence transformer model...")
+            from sentence_transformers import SentenceTransformer
+            model = SentenceTransformer('all-MiniLM-L6-v2')
+            test_result = model.encode(["test"])
+            print("✅ Sentence transformer: MODEL LOADED")
+            results['sentence_model'] = True
+        except Exception as e:
+            print(f"❌ Sentence transformer: MODEL FAILED - {e}")
+            results['sentence_model'] = False
+    else:
+        results['sentence_model'] = False
+    
+    if results.get('transformers'):
+        try:
+            print("🔄 Testing paraphrasing model...")
+            from transformers import pipeline
+            paraphraser = pipeline("text2text-generation", model="google/flan-t5-small")
+            test_result = paraphraser("test sentence", max_length=50)
+            print("✅ Paraphrasing: MODEL LOADED")
+            results['paraphrase_model'] = True
+        except Exception as e:
+            print(f"❌ Paraphrasing: MODEL FAILED - {e}")
+            results['paraphrase_model'] = False
+    else:
+        results['paraphrase_model'] = False
+    
+    # Analyze issues and provide fixes
+    print(f"\n🎯 DIAGNOSIS & SOLUTIONS:")
+    print("-" * 30)
+    
+    if not results['sentence_transformers']:
+        print("🚨 ISSUE: sentence-transformers not working")
+        print("💡 SOLUTION:")
+        print("   pip uninstall -y sentence-transformers huggingface_hub")
+        print("   pip install huggingface_hub==0.17.3")
+        print("   pip install sentence-transformers==2.2.2")
+        print()
+        
+        fix = input("🔧 Apply this fix now? (y/n): ").lower().strip()
+        if fix == 'y':
+            print("🔄 Applying sentence-transformers fix...")
+            success1, _ = run_pip_command("pip uninstall -y sentence-transformers huggingface_hub")
+            success2, _ = run_pip_command("pip install huggingface_hub==0.17.3")
+            success3, _ = run_pip_command("pip install sentence-transformers==2.2.2")
+            
+            if success1 and success2 and success3:
+                print("✅ Fix applied successfully!")
+                # Test again
+                success, message = test_import('sentence_transformers', 'SentenceTransformer')
+                if success:
+                    print("✅ sentence-transformers now working!")
+                    results['sentence_transformers'] = True
+                else:
+                    print(f"❌ Still not working: {message}")
+            else:
+                print("❌ Fix failed")
+    
+    if not results['transformers']:
+        print("🚨 ISSUE: transformers not working")
+        print("💡 SOLUTION:")
+        print("   pip install transformers==4.35.0 torch")
+        print()
+        
+        fix = input("🔧 Apply this fix now? (y/n): ").lower().strip()
+        if fix == 'y':
+            print("🔄 Applying transformers fix...")
+            success1, _ = run_pip_command("pip install transformers==4.35.0")
+            success2, _ = run_pip_command("pip install torch")
+            
+            if success1 and success2:
+                print("✅ Fix applied successfully!")
+                success, message = test_import('transformers', 'pipeline')
+                if success:
+                    print("✅ transformers now working!")
+                    results['transformers'] = True
+                else:
+                    print(f"❌ Still not working: {message}")
+            else:
+                print("❌ Fix failed")
+    
+    # Final test with our humanizer
+    print(f"\n🧪 FINAL TEST:")
+    print("-" * 15)
+    
+    try:
+        # Try importing our production version
+        if os.path.exists("text_humanizer_production.py"):
+            sys.path.insert(0, ".")
+            from text_humanizer_production import ProductionAITextHumanizer
+            
+            print("🔄 Creating production humanizer...")
+            humanizer = ProductionAITextHumanizer()
+            
+            print("🔄 Testing humanization...")
+            result = humanizer.humanize_text_production(
+                "Furthermore, it is important to note that these systems demonstrate significant capabilities.",
+                style="conversational",
+                intensity=0.8
+            )
+            
+            print("✅ PRODUCTION TEST SUCCESSFUL!")
+            print(f"Original: Furthermore, it is important to note that...")
+            print(f"Humanized: {result['humanized_text']}")
+            print(f"Quality Score: {result['quality_score']:.3f}")
+            
+            # Check what features are working
+            working_features = sum([
+                results.get('sentence_model', False),
+                results.get('paraphrase_model', False),
+                True,  # Basic features always work
+            ])
+            
+            if working_features >= 2:
+                print("🎉 PRODUCTION READY!")
+            else:
+                print("⚠️ Limited features - but still functional")
+                
+        else:
+            print("❌ text_humanizer_production.py not found")
+    
+    except Exception as e:
+        print(f"❌ Final test failed: {e}")
+    
+    # Summary and next steps
+    print(f"\n📊 SUMMARY:")
+    print("-" * 12)
+    
+    working_count = sum([
+        results.get('sentence_transformers', False),
+        results.get('transformers', False),
+        results.get('sentence_model', False),
+        results.get('paraphrase_model', False)
+    ])
+    
+    if working_count >= 3:
+        print("🎉 ALL ADVANCED FEATURES WORKING!")
+        print("✅ Your AI Text Humanizer is production-ready")
+        print("\n🚀 Next steps:")
+        print("   python text_humanizer_production.py  # Test it")
+        print("   python fastapi_server.py             # Run API")
+        print("   python gradio_app.py                 # Run web UI")
+        
+    elif working_count >= 1:
+        print("⚠️ SOME FEATURES WORKING")
+        print("✅ Your humanizer will work with reduced functionality")
+        print("\n🚀 To enable all features, run the fixes above")
+        
+    else:
+        print("❌ CRITICAL ISSUES DETECTED")
+        print("💡 Run this command for a fresh start:")
+        print("   python install_production.py")
+    
+    print(f"\n📞 Need help? Check:")
+    print("   - README.md for detailed setup")
+    print("   - DEPENDENCY_FIX.md for troubleshooting")
+    print("   - Run: python install_production.py")
+
+if __name__ == "__main__":
+    main()

install_production.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+"""
+Production Installation Script for AI Text Humanizer
+Ensures all advanced features are properly installed and working
+"""
+
+import subprocess
+import sys
+import os
+import time
+
+def run_command(cmd, description, critical=True):
+    """Run a command and handle errors"""
+    print(f"🔄 {description}...")
+    try:
+        result = subprocess.run(cmd, shell=True, check=True, capture_output=True, text=True)
+        print(f"✅ {description} - SUCCESS")
+        if result.stdout.strip():
+            print(f"   Output: {result.stdout.strip()}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ {description} - FAILED")
+        print(f"   Error: {e.stderr.strip()}")
+        if critical:
+            return False
+        return True
+
+def check_gpu_availability():
+    """Check if CUDA/GPU is available for better performance"""
+    try:
+        result = subprocess.run(["nvidia-smi"], capture_output=True, text=True)
+        if result.returncode == 0:
+            print("🚀 NVIDIA GPU detected - will install CUDA support")
+            return True
+    except FileNotFoundError:
+        pass
+    
+    print("💻 No NVIDIA GPU detected - using CPU versions")
+    return False
+
+def production_install():
+    """Install production-grade AI Text Humanizer with all features"""
+    print("🏭 AI TEXT HUMANIZER - PRODUCTION INSTALLATION")
+    print("=" * 55)
+    print("📋 This will install ALL advanced features:")
+    print("   ✨ Advanced semantic similarity (sentence-transformers)")
+    print("   🧠 AI paraphrasing capabilities (transformers)")
+    print("   🚀 GPU acceleration (if available)")
+    print("   📊 Full API and web interfaces")
+    print("")
+    
+    # Check system
+    has_gpu = check_gpu_availability()
+    
+    print("🔧 Starting production installation...")
+    print("-" * 40)
+    
+    # Step 1: Clean existing installation
+    print("\n📦 STEP 1: Cleaning existing installation")
+    cleanup_commands = [
+        "pip uninstall -y sentence-transformers transformers huggingface_hub torch torchvision torchaudio",
+        "pip cache purge"
+    ]
+    
+    for cmd in cleanup_commands:
+        run_command(cmd, "Cleaning previous installation", critical=False)
+    
+    # Step 2: Upgrade pip and install build tools
+    print("\n🔨 STEP 2: Installing build tools")
+    build_commands = [
+        "pip install --upgrade pip setuptools wheel",
+        "pip install --upgrade packaging"
+    ]
+    
+    for cmd in build_commands:
+        if not run_command(cmd, "Installing build tools"):
+            return False
+    
+    # Step 3: Install PyTorch (choose CPU or GPU version)
+    print("\n🧠 STEP 3: Installing PyTorch")
+    if has_gpu:
+        torch_cmd = "pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121"
+    else:
+        torch_cmd = "pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu"
+    
+    if not run_command(torch_cmd, "Installing PyTorch with proper backend"):
+        print("⚠️ PyTorch installation failed, trying alternative...")
+        if not run_command("pip install torch==2.1.0", "Installing PyTorch (fallback)"):
+            return False
+    
+    # Step 4: Install HuggingFace ecosystem with compatible versions
+    print("\n🤗 STEP 4: Installing HuggingFace ecosystem")
+    hf_commands = [
+        "pip install huggingface_hub==0.17.3",
+        "pip install tokenizers==0.14.1", 
+        "pip install transformers==4.35.0",
+        "pip install accelerate==0.24.1"
+    ]
+    
+    for cmd in hf_commands:
+        if not run_command(cmd, f"Installing {cmd.split()[1]}"):
+            return False
+    
+    # Step 5: Install sentence transformers
+    print("\n🔤 STEP 5: Installing Sentence Transformers")
+    if not run_command("pip install sentence-transformers==2.2.2", "Installing Sentence Transformers"):
+        print("⚠️ Trying alternative installation...")
+        if not run_command("pip install sentence-transformers==2.1.0", "Installing Sentence Transformers (fallback)"):
+            return False
+    
+    # Step 6: Install additional ML libraries
+    print("\n📊 STEP 6: Installing ML libraries")
+    ml_commands = [
+        "pip install scikit-learn==1.3.2",
+        "pip install numpy==1.25.2", 
+        "pip install pandas==2.1.3",
+        "pip install nltk==3.8.1"
+    ]
+    
+    for cmd in ml_commands:
+        if not run_command(cmd, f"Installing {cmd.split()[1]}"):
+            return False
+    
+    # Step 7: Install web frameworks
+    print("\n🌐 STEP 7: Installing web frameworks")
+    web_commands = [
+        "pip install fastapi==0.104.1",
+        "pip install uvicorn[standard]==0.24.0",
+        "pip install gradio==4.7.1",
+        "pip install python-multipart==0.0.6",
+        "pip install aiofiles==23.2.1",
+        "pip install requests==2.31.0"
+    ]
+    
+    for cmd in web_commands:
+        if not run_command(cmd, f"Installing {cmd.split()[1]}"):
+            return False
+    
+    # Step 8: Install optional production libraries
+    print("\n⚡ STEP 8: Installing production libraries")
+    prod_commands = [
+        "pip install redis==5.0.1",
+        "pip install psutil",
+        "pip install python-dotenv"
+    ]
+    
+    for cmd in prod_commands:
+        run_command(cmd, f"Installing {cmd.split()[1]}", critical=False)
+    
+    # Step 9: Download NLTK data
+    print("\n📚 STEP 9: Downloading NLTK data")
+    nltk_downloads = [
+        "python -c \"import nltk; nltk.download('punkt', quiet=True)\"",
+        "python -c \"import nltk; nltk.download('wordnet', quiet=True)\"",
+        "python -c \"import nltk; nltk.download('omw-1.4', quiet=True)\"",
+        "python -c \"import nltk; nltk.download('stopwords', quiet=True)\""
+    ]
+    
+    for cmd in nltk_downloads:
+        run_command(cmd, "Downloading NLTK data", critical=False)
+    
+    # Step 10: Pre-download models
+    print("\n🤖 STEP 10: Pre-downloading models")
+    model_downloads = [
+        "python -c \"from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')\"",
+        "python -c \"from transformers import pipeline; pipeline('text2text-generation', model='google/flan-t5-small')\""
+    ]
+    
+    for cmd in model_downloads:
+        run_command(cmd, "Pre-downloading models", critical=False)
+    
+    print(f"\n🎉 INSTALLATION COMPLETED!")
+    return True
+
+def test_installation():
+    """Test if all components are working"""
+    print(f"\n🧪 TESTING INSTALLATION")
+    print("=" * 30)
+    
+    test_results = {}
+    
+    # Test imports
+    imports_to_test = [
+        ("sentence_transformers", "SentenceTransformer"),
+        ("transformers", "pipeline"), 
+        ("torch", None),
+        ("sklearn", None),
+        ("nltk", None),
+        ("gradio", None),
+        ("fastapi", None)
+    ]
+    
+    for module, component in imports_to_test:
+        try:
+            if component:
+                exec(f"from {module} import {component}")
+            else:
+                exec(f"import {module}")
+            print(f"✅ {module}: Import successful")
+            test_results[module] = True
+        except Exception as e:
+            print(f"❌ {module}: Import failed - {e}")
+            test_results[module] = False
+    
+    # Test model loading
+    print(f"\n🤖 Testing model loading...")
+    
+    try:
+        from sentence_transformers import SentenceTransformer
+        model = SentenceTransformer('all-MiniLM-L6-v2')
+        print("✅ Sentence transformer: Model loaded successfully")
+        test_results['sentence_model'] = True
+    except Exception as e:
+        print(f"❌ Sentence transformer: Model loading failed - {e}")
+        test_results['sentence_model'] = False
+    
+    try:
+        from transformers import pipeline
+        paraphraser = pipeline("text2text-generation", model="google/flan-t5-small")
+        print("✅ Paraphrasing model: Model loaded successfully")  
+        test_results['paraphrase_model'] = True
+    except Exception as e:
+        print(f"❌ Paraphrasing model: Model loading failed - {e}")
+        test_results['paraphrase_model'] = False
+    
+    # Test GPU availability
+    try:
+        import torch
+        if torch.cuda.is_available():
+            print(f"✅ CUDA: {torch.cuda.device_count()} GPU(s) available")
+            test_results['gpu'] = True
+        else:
+            print("💻 CUDA: Not available (using CPU)")
+            test_results['gpu'] = False
+    except:
+        test_results['gpu'] = False
+    
+    return test_results
+
+def create_production_requirements():
+    """Create production requirements file"""
+    requirements = """# AI Text Humanizer - Production Requirements
+# All features enabled with compatible versions
+
+# Core ML frameworks
+torch>=2.1.0
+transformers==4.35.0
+sentence-transformers==2.2.2
+huggingface_hub==0.17.3
+accelerate==0.24.1
+
+# NLP libraries  
+nltk==3.8.1
+scikit-learn==1.3.2
+numpy==1.25.2
+pandas==2.1.3
+
+# Web frameworks
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+gradio==4.7.1
+python-multipart==0.0.6
+aiofiles==23.2.1
+requests==2.31.0
+
+# Production libraries
+redis==5.0.1
+psutil
+python-dotenv
+
+# Build tools
+setuptools
+wheel
+packaging
+"""
+    
+    with open("requirements-production.txt", "w") as f:
+        f.write(requirements)
+    
+    print("✅ Created requirements-production.txt")
+
+def main():
+    """Main installation process"""
+    print("🚀 AI TEXT HUMANIZER - PRODUCTION SETUP")
+    print("======================================")
+    
+    # Check Python version
+    if sys.version_info < (3, 7):
+        print("❌ Python 3.7+ required")
+        return False
+    
+    print(f"🐍 Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro} detected")
+    
+    # Check virtual environment
+    in_venv = hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix)
+    if not in_venv:
+        print("⚠️ Warning: Not in virtual environment")
+        response = input("Continue? (y/n): ").lower().strip()
+        if response != 'y':
+            print("👋 Please create a virtual environment first")
+            return False
+    else:
+        print("✅ Virtual environment detected")
+    
+    # Start installation
+    if not production_install():
+        print("\n❌ Installation failed!")
+        return False
+    
+    # Test installation
+    test_results = test_installation()
+    
+    # Create requirements file
+    create_production_requirements()
+    
+    # Summary
+    print(f"\n📊 INSTALLATION SUMMARY")
+    print("=" * 30)
+    
+    success_count = sum(1 for v in test_results.values() if v)
+    total_count = len(test_results)
+    
+    print(f"✅ {success_count}/{total_count} components working")
+    
+    if test_results.get('sentence_model') and test_results.get('paraphrase_model'):
+        print("🎉 ALL ADVANCED FEATURES ENABLED!")
+        print("   • Advanced semantic similarity ✅")
+        print("   • AI paraphrasing capabilities ✅")
+        print("   • Production-ready performance ✅")
+    elif test_results.get('sentence_model'):
+        print("⚠️ Advanced similarity enabled, paraphrasing needs attention")
+    elif test_results.get('paraphrase_model'):
+        print("⚠️ Paraphrasing enabled, similarity needs attention")
+    else:
+        print("❌ Advanced features need troubleshooting")
+    
+    print(f"\n🎯 NEXT STEPS:")
+    print("1. Test: python text_humanizer_robust.py")
+    print("2. Run API: python fastapi_server.py") 
+    print("3. Run web UI: python gradio_app.py")
+    
+    return success_count >= total_count - 2  # Allow 2 optional failures
+
+if __name__ == "__main__":
+    try:
+        success = main()
+        if success:
+            print(f"\n🎉 Production installation successful!")
+        else:
+            print(f"\n❌ Production installation needs attention")
+    except KeyboardInterrupt:
+        print(f"\n👋 Installation cancelled")
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {e}")

requirements.txt

@@ -1,10 +1,20 @@
-# Minimal requirements for Hugging Face Spaces to avoid dependency conflicts
-gradio==4.7.1
+# Core ML frameworks
+torch>=2.1.0
+transformers==4.35.0
+sentence-transformers==2.2.2
+huggingface_hub==0.17.3
+accelerate==0.24.1
+
+# NLP and processing libraries
 nltk==3.8.1
-numpy==1.25.2
 scikit-learn==1.3.2
+numpy==1.25.2
+pandas==2.1.3
+
+# Web interface
+gradio==4.7.1
 
-# Optional dependencies (will be installed if available)
-# sentence-transformers==2.2.2
-# transformers==4.35.0
-# torch==2.1.0
+# Build and utility libraries
+setuptools
+wheel
+packaging

text_humanizer_production.py

@@ -0,0 +1,585 @@
+import re
+import random
+import nltk
+from typing import List, Dict, Optional
+import numpy as np
+
+# Download required NLTK data
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+
+try:
+    nltk.data.find('corpora/wordnet')
+except LookupError:
+    nltk.download('wordnet')
+
+try:
+    nltk.data.find('corpora/omw-1.4')
+except LookupError:
+    nltk.download('omw-1.4')
+
+from nltk.tokenize import sent_tokenize, word_tokenize
+
+# Production-grade imports with proper error handling and retries
+def safe_import_with_retry(module_name, component=None, max_retries=3):
+    """Import with retries and detailed error reporting"""
+    for attempt in range(max_retries):
+        try:
+            if component:
+                module = __import__(module_name, fromlist=[component])
+                return getattr(module, component), True
+            else:
+                return __import__(module_name), True
+        except ImportError as e:
+            if attempt < max_retries - 1:
+                print(f"⚠️ Import attempt {attempt + 1} failed for {module_name}: {e}")
+                print(f"🔄 Retrying in 2 seconds...")
+                import time
+                time.sleep(2)
+                continue
+            else:
+                print(f"❌ Final import failed for {module_name}: {e}")
+                return None, False
+        except Exception as e:
+            print(f"❌ Unexpected error importing {module_name}: {e}")
+            return None, False
+    return None, False
+
+# Advanced model imports with retries
+print("🚀 Loading AI Text Humanizer - Production Version...")
+print("=" * 50)
+
+print("📥 Loading sentence transformers...")
+SentenceTransformer, SENTENCE_TRANSFORMERS_AVAILABLE = safe_import_with_retry('sentence_transformers', 'SentenceTransformer')
+
+print("📥 Loading transformers pipeline...")
+pipeline, TRANSFORMERS_AVAILABLE = safe_import_with_retry('transformers', 'pipeline')
+
+print("📥 Loading scikit-learn...")
+try:
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    from sklearn.metrics.pairwise import cosine_similarity as sklearn_cosine_similarity
+    SKLEARN_AVAILABLE = True
+    print("✅ Scikit-learn loaded successfully")
+except ImportError as e:
+    print(f"⚠️ Scikit-learn not available: {e}")
+    SKLEARN_AVAILABLE = False
+
+# Additional production imports
+try:
+    import torch
+    TORCH_AVAILABLE = True
+    print(f"✅ PyTorch loaded - CUDA available: {torch.cuda.is_available()}")
+except ImportError:
+    TORCH_AVAILABLE = False
+    print("⚠️ PyTorch not available")
+
+class ProductionAITextHumanizer:
+    def __init__(self, enable_gpu=True, model_cache_dir=None):
+        """Initialize production-grade text humanizer with all advanced features"""
+        print("🏭 Initializing Production AI Text Humanizer...")
+        
+        self.enable_gpu = enable_gpu and TORCH_AVAILABLE
+        self.model_cache_dir = model_cache_dir
+        
+        # Initialize advanced models with detailed error handling
+        self._load_similarity_model()
+        self._load_paraphrasing_model()
+        self._initialize_fallback_methods()
+        self._setup_word_mappings()
+        
+        print("✅ Production AI Text Humanizer initialized!")
+        self._print_feature_status()
+    
+    def _load_similarity_model(self):
+        """Load sentence transformer with production settings"""
+        self.similarity_model = None
+        
+        if SENTENCE_TRANSFORMERS_AVAILABLE and SentenceTransformer:
+            try:
+                print("🔄 Loading sentence transformer model...")
+                
+                # Production settings
+                model_kwargs = {
+                    'device': 'cuda' if self.enable_gpu and torch.cuda.is_available() else 'cpu'
+                } if TORCH_AVAILABLE else {}
+                
+                if self.model_cache_dir:
+                    model_kwargs['cache_folder'] = self.model_cache_dir
+                
+                self.similarity_model = SentenceTransformer(
+                    'all-MiniLM-L6-v2',
+                    **model_kwargs
+                )
+                
+                # Test the model
+                test_embedding = self.similarity_model.encode(["test sentence"])
+                print("✅ Sentence transformer model loaded and tested successfully!")
+                
+            except Exception as e:
+                print(f"❌ Failed to load sentence transformer: {e}")
+                print("💡 Troubleshooting tips:")
+                print("   - Check internet connection for model download")
+                print("   - Verify sentence-transformers version: pip install sentence-transformers==2.2.2")
+                print("   - Check CUDA compatibility if using GPU")
+                self.similarity_model = None
+        else:
+            print("❌ Sentence transformers not available")
+    
+    def _load_paraphrasing_model(self):
+        """Load paraphrasing model with production settings"""
+        self.paraphraser = None
+        
+        if TRANSFORMERS_AVAILABLE and pipeline:
+            try:
+                print("🔄 Loading paraphrasing model...")
+                
+                # Production settings
+                device = 0 if self.enable_gpu and TORCH_AVAILABLE and torch.cuda.is_available() else -1
+                
+                self.paraphraser = pipeline(
+                    "text2text-generation",
+                    model="google/flan-t5-small",
+                    device=device,
+                    max_length=512,
+                    model_kwargs={"cache_dir": self.model_cache_dir} if self.model_cache_dir else {}
+                )
+                
+                # Test the model
+                test_result = self.paraphraser("Test sentence for paraphrasing.", max_length=50)
+                print("✅ Paraphrasing model loaded and tested successfully!")
+                
+            except Exception as e:
+                print(f"❌ Failed to load paraphrasing model: {e}")
+                print("💡 Troubleshooting tips:")
+                print("   - Check internet connection for model download")
+                print("   - Verify transformers version: pip install transformers==4.35.0")
+                print("   - Check available memory (models need ~2GB RAM)")
+                self.paraphraser = None
+        else:
+            print("❌ Transformers not available")
+    
+    def _initialize_fallback_methods(self):
+        """Initialize fallback similarity methods"""
+        self.tfidf_vectorizer = None
+        if SKLEARN_AVAILABLE:
+            try:
+                self.tfidf_vectorizer = TfidfVectorizer(
+                    stop_words='english', 
+                    ngram_range=(1, 2),
+                    max_features=5000
+                )
+                print("✅ TF-IDF fallback similarity initialized")
+            except Exception as e:
+                print(f"⚠️ TF-IDF initialization failed: {e}")
+    
+    def _setup_word_mappings(self):
+        """Setup comprehensive word mappings for production"""
+        # Extended formal to casual mappings for production
+        self.formal_to_casual = {
+            # Basic formal words
+            "utilize": "use", "demonstrate": "show", "facilitate": "help",
+            "implement": "do", "consequently": "so", "therefore": "so",
+            "nevertheless": "but", "furthermore": "also", "moreover": "also",
+            "subsequently": "then", "accordingly": "so", "regarding": "about",
+            "concerning": "about", "pertaining": "about", "approximately": "about",
+            "endeavor": "try", "commence": "start", "terminate": "end",
+            "obtain": "get", "purchase": "buy", "examine": "look at",
+            "analyze": "study", "construct": "build", "establish": "set up",
+            
+            # Advanced formal words  
+            "magnitude": "size", "comprehensive": "complete", "significant": "big",
+            "substantial": "large", "optimal": "best", "sufficient": "enough",
+            "adequate": "good enough", "exceptional": "amazing", "remarkable": "great",
+            "outstanding": "excellent", "predominant": "main", "fundamental": "basic",
+            "essential": "needed", "crucial": "important", "vital": "key",
+            "paramount": "most important", "imperative": "must", "mandatory": "required",
+            
+            # Formal phrases
+            "prior to": "before", "in order to": "to", "due to the fact that": "because",
+            "at this point in time": "now", "in the event that": "if",
+            "it is important to note": "note that", "it should be emphasized": "remember",
+            "it is worth mentioning": "by the way", "it is crucial to understand": "importantly",
+            "for the purpose of": "to", "with regard to": "about",
+            "in accordance with": "following", "as a result of": "because of",
+            "in spite of the fact that": "although", "on the other hand": "however",
+            
+            # Academic/business terms
+            "methodology": "method", "systematically": "step by step",
+            "optimization": "improvement", "enhancement": "upgrade",
+            "implementation": "setup", "utilization": "use", "evaluation": "review",
+            "assessment": "check", "validation": "proof", "verification": "confirmation",
+            "consolidation": "combining", "integration": "bringing together",
+            "transformation": "change", "modification": "change", "alteration": "change"
+        }
+        
+        # Extended contractions
+        self.contractions = {
+            "do not": "don't", "does not": "doesn't", "did not": "didn't",
+            "will not": "won't", "would not": "wouldn't", "should not": "shouldn't",
+            "could not": "couldn't", "cannot": "can't", "is not": "isn't",
+            "are not": "aren't", "was not": "wasn't", "were not": "weren't",
+            "have not": "haven't", "has not": "hasn't", "had not": "hadn't",
+            "I am": "I'm", "you are": "you're", "he is": "he's", "she is": "she's",
+            "it is": "it's", "we are": "we're", "they are": "they're",
+            "I have": "I've", "you have": "you've", "we have": "we've",
+            "they have": "they've", "I will": "I'll", "you will": "you'll",
+            "he will": "he'll", "she will": "she'll", "it will": "it'll",
+            "we will": "we'll", "they will": "they'll", "would have": "would've",
+            "should have": "should've", "could have": "could've", "might have": "might've"
+        }
+        
+        # AI-like transitions (expanded)
+        self.ai_transition_words = [
+            "Furthermore,", "Moreover,", "Additionally,", "Subsequently,",
+            "Consequently,", "Therefore,", "Nevertheless,", "However,",
+            "In conclusion,", "To summarize,", "In summary,", "Overall,",
+            "It is important to note that", "It should be emphasized that",
+            "It is worth mentioning that", "It is crucial to understand that",
+            "It is essential to recognize that", "It must be acknowledged that",
+            "It should be noted that", "It is imperative to understand",
+            "From a practical standpoint,", "From an analytical perspective,",
+            "In terms of implementation,", "With respect to the aforementioned,",
+            "As previously mentioned,", "As stated earlier,", "In light of this,"
+        ]
+        
+        # Natural alternatives (expanded)
+        self.natural_transitions = [
+            "Also,", "Plus,", "And,", "Then,", "So,", "But,", "Still,",
+            "Anyway,", "By the way,", "Actually,", "Basically,", "Look,",
+            "Listen,", "Here's the thing:", "The point is,", "What's more,",
+            "On top of that,", "Another thing,", "Now,", "Well,", "You know,",
+            "I mean,", "Honestly,", "Frankly,", "Simply put,", "In other words,",
+            "To put it differently,", "Let me explain,", "Here's what I mean:",
+            "Think about it,", "Consider this,", "Get this,", "Check this out,"
+        ]
+    
+    def _print_feature_status(self):
+        """Print detailed feature status for production monitoring"""
+        print("\n📊 PRODUCTION FEATURE STATUS:")
+        print("-" * 40)
+        print(f"🔤 Advanced Similarity: {'✅ ENABLED' if self.similarity_model else '❌ DISABLED'}")
+        print(f"🧠 AI Paraphrasing: {'✅ ENABLED' if self.paraphraser else '❌ DISABLED'}")
+        print(f"📊 TF-IDF Fallback: {'✅ ENABLED' if self.tfidf_vectorizer else '❌ DISABLED'}")
+        print(f"🚀 GPU Acceleration: {'✅ ENABLED' if self.enable_gpu and TORCH_AVAILABLE else '❌ DISABLED'}")
+        print(f"⚡ Word Mappings: ✅ ENABLED ({len(self.formal_to_casual)} mappings)")
+        print(f"📝 Contractions: ✅ ENABLED ({len(self.contractions)} contractions)")
+        
+        if TORCH_AVAILABLE:
+            import torch
+            print(f"🖥️ Device: {'CUDA' if torch.cuda.is_available() and self.enable_gpu else 'CPU'}")
+        
+        # Calculate feature completeness
+        total_features = 6
+        enabled_features = sum([
+            bool(self.similarity_model),
+            bool(self.paraphraser), 
+            bool(self.tfidf_vectorizer),
+            True,  # Word mappings always available
+            True,  # Contractions always available
+            TORCH_AVAILABLE
+        ])
+        
+        completeness = (enabled_features / total_features) * 100
+        print(f"🎯 Feature Completeness: {completeness:.1f}%")
+        
+        if completeness < 70:
+            print("⚠️ WARNING: Less than 70% features enabled - not production ready")
+        elif completeness < 90:
+            print("⚠️ CAUTION: Some advanced features missing")
+        else:
+            print("🎉 PRODUCTION READY: All critical features enabled!")
+    
+    def add_contractions(self, text: str) -> str:
+        """Add contractions with improved pattern matching"""
+        # Sort by length (longest first) to avoid partial replacements
+        sorted_contractions = sorted(self.contractions.items(), key=lambda x: len(x[0]), reverse=True)
+        
+        for formal, casual in sorted_contractions:
+            # Use word boundaries to avoid partial matches
+            pattern = r'\b' + re.escape(formal) + r'\b'
+            text = re.sub(pattern, casual, text, flags=re.IGNORECASE)
+        
+        return text
+    
+    def replace_formal_words(self, text: str, replacement_rate: float = 0.8) -> str:
+        """Enhanced formal word replacement with context awareness"""
+        # Handle phrases first (longer matches)
+        phrase_replacements = {k: v for k, v in self.formal_to_casual.items() if len(k.split()) > 1}
+        word_replacements = {k: v for k, v in self.formal_to_casual.items() if len(k.split()) == 1}
+        
+        # Replace phrases first
+        for formal_phrase, casual_phrase in phrase_replacements.items():
+            if random.random() < replacement_rate:
+                pattern = r'\b' + re.escape(formal_phrase) + r'\b'
+                text = re.sub(pattern, casual_phrase, text, flags=re.IGNORECASE)
+        
+        # Then replace individual words
+        words = word_tokenize(text)
+        for i, word in enumerate(words):
+            word_clean = word.lower().strip('.,!?;:"')
+            if word_clean in word_replacements and random.random() < replacement_rate:
+                replacement = word_replacements[word_clean]
+                # Preserve case
+                if word.isupper():
+                    words[i] = word.replace(word_clean, replacement.upper())
+                elif word.istitle():
+                    words[i] = word.replace(word_clean, replacement.title())
+                else:
+                    words[i] = word.replace(word_clean, replacement)
+        
+        # Reconstruct with proper spacing
+        result = ""
+        for i, word in enumerate(words):
+            if i > 0 and word not in ".,!?;:\"')":
+                result += " "
+            result += word
+        
+        return result
+    
+    def replace_ai_transitions(self, text: str) -> str:
+        """Enhanced AI transition replacement with context awareness"""
+        # Sort by length to handle longer phrases first
+        sorted_transitions = sorted(self.ai_transition_words, key=len, reverse=True)
+        
+        for ai_transition in sorted_transitions:
+            if ai_transition in text:
+                # Choose appropriate natural replacement based on context
+                natural_replacement = random.choice(self.natural_transitions)
+                
+                # Adjust replacement based on sentence position
+                if text.startswith(ai_transition):
+                    # Beginning of text
+                    text = text.replace(ai_transition, natural_replacement, 1)
+                else:
+                    # Middle of text - be more selective
+                    if random.random() < 0.7:  # 70% chance to replace
+                        text = text.replace(ai_transition, natural_replacement, 1)
+        
+        return text
+    
+    def advanced_paraphrasing(self, text: str, paraphrase_rate: float = 0.4) -> str:
+        """Production-grade paraphrasing with quality control"""
+        if not self.paraphraser:
+            return text
+        
+        sentences = sent_tokenize(text)
+        paraphrased_sentences = []
+        
+        for sentence in sentences:
+            # Only paraphrase longer, more complex sentences
+            if len(sentence.split()) > 10 and random.random() < paraphrase_rate:
+                try:
+                    # Multiple paraphrasing strategies
+                    prompts = [
+                        f"Rewrite this more naturally: {sentence}",
+                        f"Make this sound more conversational: {sentence}",
+                        f"Rephrase this in simpler terms: {sentence}",
+                        f"Say this in a more casual way: {sentence}"
+                    ]
+                    
+                    prompt = random.choice(prompts)
+                    
+                    result = self.paraphraser(
+                        prompt,
+                        max_length=len(sentence) + 50,
+                        min_length=max(10, len(sentence) // 2),
+                        num_return_sequences=1,
+                        temperature=0.7,
+                        do_sample=True
+                    )
+                    
+                    paraphrased = result[0]['generated_text']
+                    paraphrased = paraphrased.replace(prompt, '').strip().strip('"\'')
+                    
+                    # Quality checks
+                    if (paraphrased and 
+                        len(paraphrased) > 5 and 
+                        len(paraphrased) < len(sentence) * 2 and
+                        not paraphrased.lower().startswith(('i cannot', 'i can\'t', 'sorry'))):
+                        paraphrased_sentences.append(paraphrased)
+                    else:
+                        paraphrased_sentences.append(sentence)
+                        
+                except Exception as e:
+                    print(f"⚠️ Paraphrasing failed: {e}")
+                    paraphrased_sentences.append(sentence)
+            else:
+                paraphrased_sentences.append(sentence)
+        
+        return ' '.join(paraphrased_sentences)
+    
+    def calculate_similarity_advanced(self, text1: str, text2: str) -> float:
+        """Production-grade similarity calculation"""
+        if self.similarity_model:
+            try:
+                embeddings1 = self.similarity_model.encode([text1])
+                embeddings2 = self.similarity_model.encode([text2])
+                similarity = np.dot(embeddings1[0], embeddings2[0]) / (
+                    np.linalg.norm(embeddings1[0]) * np.linalg.norm(embeddings2[0])
+                )
+                return float(similarity)
+            except Exception as e:
+                print(f"⚠️ Advanced similarity calculation failed: {e}")
+        
+        # Fallback to TF-IDF
+        if self.tfidf_vectorizer and SKLEARN_AVAILABLE:
+            try:
+                tfidf_matrix = self.tfidf_vectorizer.fit_transform([text1, text2])
+                similarity = sklearn_cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])[0][0]
+                return float(similarity)
+            except Exception as e:
+                print(f"⚠️ TF-IDF similarity calculation failed: {e}")
+        
+        # Basic fallback
+        words1 = set(word_tokenize(text1.lower()))
+        words2 = set(word_tokenize(text2.lower()))
+        if not words1 or not words2:
+            return 1.0 if text1 == text2 else 0.0
+        
+        intersection = words1.intersection(words2)
+        union = words1.union(words2)
+        return len(intersection) / len(union) if union else 1.0
+    
+    def humanize_text_production(self, 
+                                text: str, 
+                                style: str = "natural",
+                                intensity: float = 0.8,
+                                preserve_length: bool = True,
+                                quality_threshold: float = 0.75) -> Dict:
+        """
+        Production-grade text humanization with comprehensive quality control
+        
+        Args:
+            text: Input text to humanize
+            style: Style ('natural', 'casual', 'conversational')
+            intensity: Transformation intensity (0.0 to 1.0)
+            preserve_length: Try to maintain similar text length
+            quality_threshold: Minimum similarity score to accept
+            
+        Returns:
+            Comprehensive results with quality metrics
+        """
+        if not text.strip():
+            return {
+                "original_text": text,
+                "humanized_text": text,
+                "similarity_score": 1.0,
+                "changes_made": [],
+                "style": style,
+                "intensity": intensity,
+                "quality_score": 1.0,
+                "processing_time_ms": 0.0,
+                "feature_usage": {}
+            }
+        
+        import time
+        start_time = time.time()
+        
+        changes_made = []
+        humanized_text = text
+        original_text = text
+        feature_usage = {}
+        
+        # Step 1: AI transition replacement (early to catch obvious AI patterns)
+        if intensity > 0.2:
+            before = humanized_text
+            humanized_text = self.replace_ai_transitions(humanized_text)
+            if humanized_text != before:
+                changes_made.append("Replaced AI-like transition phrases")
+                feature_usage['ai_transitions'] = True
+        
+        # Step 2: Formal word replacement
+        if intensity > 0.3:
+            before = humanized_text
+            humanized_text = self.replace_formal_words(humanized_text, intensity * 0.9)
+            if humanized_text != before:
+                changes_made.append("Replaced formal words with casual alternatives")
+                feature_usage['word_replacement'] = True
+        
+        # Step 3: Add contractions
+        if intensity > 0.4:
+            before = humanized_text
+            humanized_text = self.add_contractions(humanized_text)
+            if humanized_text != before:
+                changes_made.append("Added natural contractions")
+                feature_usage['contractions'] = True
+        
+        # Step 4: Advanced paraphrasing (if available)
+        if intensity > 0.6 and self.paraphraser:
+            before = humanized_text
+            humanized_text = self.advanced_paraphrasing(humanized_text, intensity * 0.5)
+            if humanized_text != before:
+                changes_made.append("Applied AI paraphrasing for natural flow")
+                feature_usage['paraphrasing'] = True
+        
+        # Step 5: Calculate quality metrics
+        processing_time = (time.time() - start_time) * 1000
+        similarity_score = self.calculate_similarity_advanced(original_text, humanized_text)
+        
+        # Quality control - revert if similarity too low
+        if similarity_score < quality_threshold:
+            print(f"⚠️ Quality check failed (similarity: {similarity_score:.3f})")
+            humanized_text = original_text
+            similarity_score = 1.0
+            changes_made = ["Quality threshold not met - reverted to original"]
+            feature_usage['quality_control'] = True
+        
+        # Calculate comprehensive quality score
+        length_ratio = len(humanized_text) / len(original_text) if original_text else 1.0
+        length_penalty = max(0, 1.0 - abs(length_ratio - 1.0)) if preserve_length else 1.0
+        change_score = min(1.0, len(changes_made) / 5.0)  # Reward meaningful changes
+        
+        quality_score = (similarity_score * 0.5) + (length_penalty * 0.3) + (change_score * 0.2)
+        
+        return {
+            "original_text": original_text,
+            "humanized_text": humanized_text,
+            "similarity_score": similarity_score,
+            "quality_score": quality_score,
+            "changes_made": changes_made,
+            "style": style,
+            "intensity": intensity,
+            "processing_time_ms": processing_time,
+            "feature_usage": feature_usage,
+            "length_change": len(humanized_text) - len(original_text),
+            "word_count_change": len(humanized_text.split()) - len(original_text.split())
+        }
+
+# Convenience function for backward compatibility
+def AITextHumanizer():
+    """Factory function for backward compatibility"""
+    return ProductionAITextHumanizer()
+
+# Test the production version
+if __name__ == "__main__":
+    humanizer = ProductionAITextHumanizer()
+    
+    test_texts = [
+        "Furthermore, it is important to note that artificial intelligence systems demonstrate significant capabilities.",
+        "The implementation of comprehensive methodologies will facilitate optimization and enhance operational efficiency.",
+        "Subsequently, organizations must utilize systematic approaches to evaluate and implement technological solutions."
+    ]
+    
+    print(f"\n🧪 TESTING PRODUCTION HUMANIZER")
+    print("=" * 40)
+    
+    for i, test_text in enumerate(test_texts, 1):
+        print(f"\n🔬 Test {i}:")
+        print(f"Original: {test_text}")
+        
+        result = humanizer.humanize_text_production(
+            text=test_text,
+            style="conversational", 
+            intensity=0.8
+        )
+        
+        print(f"Humanized: {result['humanized_text']}")
+        print(f"Quality Score: {result['quality_score']:.3f}")
+        print(f"Similarity: {result['similarity_score']:.3f}")
+        print(f"Processing: {result['processing_time_ms']:.1f}ms")
+        print(f"Changes: {', '.join(result['changes_made']) if result['changes_made'] else 'None'}")
+    
+    print(f"\n🎉 Production testing completed!")