nIIII

app.py

@@ -10,16 +10,15 @@ import gradio as gr
 
 # =================== CONFIGURATION ===================
 MODEL_ID = "abdelac/Mistral_Test"
-USE_QUANTIZATION = True  # MUST be True for 16GB RAM
+USE_QUANTIZATION = True
 
 # =================== QUANTIZATION SETUP ===================
 if USE_QUANTIZATION:
     bnb_config = BitsAndBytesConfig(
-        load_in_4bit=True,                    # Critical for memory
-        bnb_4bit_quant_type="nf4",           # 4-bit quantization
-        bnb_4bit_compute_dtype=torch.float16, # Compute in float16
-        bnb_4bit_use_double_quant=True,      # Extra memory savings
-        llm_int8_enable_fp32_cpu_offload=True  # Offload to CPU if needed
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.float16,
+        bnb_4bit_use_double_quant=True,
     )
 else:
     bnb_config = None
@@ -33,7 +32,7 @@ def load_model():
     # Load tokenizer
     tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
     
-    # Configure model loading based on quantization
+    # Configure model loading
     load_kwargs = {
         "torch_dtype": torch.float16,
         "device_map": "auto",
@@ -42,10 +41,10 @@ def load_model():
     
     if USE_QUANTIZATION:
         load_kwargs["quantization_config"] = bnb_config
-        print("✅ Using 4-bit quantization (~4GB RAM)")
+        print("✅ Using 4-bit quantization")
     else:
         load_kwargs["device_map"] = "cpu"
-        print("⚠️ Using CPU only (slow but safe)")
+        print("⚠️ Using CPU only")
     
     # Load model
     model = AutoModelForCausalLM.from_pretrained(
@@ -53,20 +52,20 @@ def load_model():
         **load_kwargs
     )
     
-    # Set padding token if not present
+    # Set padding token
     if tokenizer.pad_token is None:
         tokenizer.pad_token = tokenizer.eos_token
     
-    print("✅ Model loaded successfully!")
+    print("✅ Model loaded!")
     return tokenizer, model
 
-# =================== MEMORY-EFFICIENT GENERATION ===================
+# =================== GENERATION FUNCTION ===================
 def generate_text(prompt, max_tokens=100, temperature=0.7):
     """Generate text with memory constraints"""
     try:
         tokenizer, model = load_model()
         
-        # Tokenize with truncation
+        # Tokenize
         inputs = tokenizer(
             prompt,
             return_tensors="pt",
@@ -74,82 +73,33 @@ def generate_text(prompt, max_tokens=100, temperature=0.7):
             max_length=512
         ).to(model.device)
         
-        # Generate with conservative settings
+        # Generate
         with torch.no_grad():
             outputs = model.generate(
                 **inputs,
-                max_new_tokens=min(max_tokens, 150),  # Cap at 150
+                max_new_tokens=min(max_tokens, 150),
                 temperature=temperature,
                 do_sample=True,
                 pad_token_id=tokenizer.eos_token_id,
-                repetition_penalty=1.1,               # Prevent repetition
-                no_repeat_ngram_size=2,
-                early_stopping=True
             )
         
-        # Decode
-        result = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        return result
+        return tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-    except torch.cuda.OutOfMemoryError:
-        return "❌ Out of memory! Try reducing max tokens or using CPU mode."
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
-# =================== SIMPLIFIED INTERFACE ===================
+# =================== SIMPLE INTERFACE ===================
 def create_interface():
-    """Create memory-aware interface"""
-    with gr.Blocks(
-        title="🦅 Mistral Test Demo",
-        theme=gr.themes.Soft()
-    ) as demo:
+    with gr.Blocks(title="Mistral Demo") as demo:
+        gr.Markdown(f"# 🦅 {MODEL_ID}")
         
-        gr.Markdown(f"""
-        # 🦅 Mistral Test Demo
+        prompt = gr.Textbox(label="Prompt", lines=3, value="Hello")
+        max_tokens = gr.Slider(30, 150, value=80, label="Max Tokens")
+        temperature = gr.Slider(0.1, 1.0, value=0.7, label="Temperature")
         
-        **Model:** [{MODEL_ID}](https://huggingface.co/{MODEL_ID})
-        **Mode:** {'4-bit Quantized' if USE_QUANTIZATION else 'CPU'}
+        generate_btn = gr.Button("Generate", variant="primary")
+        output = gr.Textbox(label="Output", lines=6)
         
-        ⚠️ **Note:** Mistral 7B requires quantization to run in 16GB RAM
-        """)
-        
-        with gr.Row():
-            prompt = gr.Textbox(
-                label="Prompt",
-                placeholder="Enter your text...",
-                lines=3,
-                value="What is artificial intelligence?"
-            )
-        
-        with gr.Row():
-            max_tokens = gr.Slider(
-                30, 150, value=80,  # Reduced max for memory
-                label="Max Tokens",
-                info="Higher values use more memory"
-            )
-            temperature = gr.Slider(
-                0.1, 1.0, value=0.7,
-                label="Temperature"
-            )
-        
-        generate_btn = gr.Button("Generate", variant="primary", size="lg")
-        
-        output = gr.Textbox(
-            label="Generated Text",
-            lines=8,
-            show_copy_button=True
-        )
-        
-        # Memory warning
-        gr.Markdown("""
-        ### 💡 Memory Optimization Tips:
-        1. **Max Tokens ≤ 100** for best results
-        2. **Temperature ~0.7** for balanced output
-        3. If OOM occurs, refresh the page
-        4. Close other tabs/applications
-        """)
-        
-        # Connect button
         generate_btn.click(
             fn=generate_text,
             inputs=[prompt, max_tokens, temperature],
@@ -160,17 +110,10 @@ def create_interface():
 
 # =================== MAIN ===================
 if __name__ == "__main__":
-    # Suppress warnings
     warnings.filterwarnings("ignore")
-    os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
-    
-    # Create and launch
     demo = create_interface()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        quiet=True,
-        debug=False,
-        show_error=True
+        quiet=True
     )