Update app.py

app.py

@@ -1,129 +1,93 @@
 import gradio as gr
-import pandas as pd
-import matplotlib.pyplot as plt
-import io
-import google.generativeai as genai
-from PIL import Image
-import ast
-import re
-
-def process_file(api_key, file, instructions):
-    genai.configure(api_key=api_key)
-    model = genai.GenerativeModel('gemini-2.5-pro-preview-03-25')
+from awq import AutoAWQForCausalLM
+from transformers import AutoTokenizer, AutoConfig
+from huggingface_hub import HfApi, login
 
+def quantize_model(
+    model_id: str,
+    hf_token: str,
+    repo_name: str,
+    progress=gr.Progress(track_tqdm=True)
+):
     try:
-        df = pd.read_csv(file.name) if file.name.endswith('.csv') else pd.read_excel(file.name)
-        if df.empty:
-            raise ValueError("Uploaded file contains no data")
-    except Exception as e:
-        print(f"Data Error: {str(e)}")
-        return [generate_error_image(str(e))]*3
-
-    # Enhanced prompt with strict plotting requirements
-    prompt = f"""Generate 3 matplotlib codes with these rules:
-    1. Use ONLY these variables: df (DataFrame), plt
-    2. Each visualization MUST:
-       - Plot actual data from df
-       - Include title, axis labels, and data labels if needed
-       - Use clear color schemes
-       - Avoid empty plots
-    3. Code structure:
-       plt.figure(figsize=(16,9), dpi=120)
-       plt.style.use('ggplot')
-       # Plotting code using df columns: {list(df.columns)}
-       plt.tight_layout()
-    
-    Sample data: {df.head(3).to_dict()}
-    User instructions: {instructions or 'General insights'}
-    
-    Format EXACTLY as:
-    # Visualization 1
-    [complete code]
-    """
-
-    try:
-        response = model.generate_content(prompt)
-        code_blocks = re.split(r'# Visualization \d+', response.text)[1:4]
-    except Exception as e:
-        return [generate_error_image("API Error")]*3
-
-    visualizations = []
-    for i, block in enumerate(code_blocks, 1):
+        # Validate credentials first
+        login(token=hf_token, add_to_git_credential=True)
+        api = HfApi(token=hf_token)
+        
+        # Check model accessibility
         try:
-            # Advanced code sanitization
-            cleaned_code = sanitize_code(block, df.columns)
-            
-            # Validate and execute
-            ast.parse(cleaned_code)
-            img = execute_plot_code(cleaned_code, df)
-            visualizations.append(img)
+            api.model_info(model_id)
         except Exception as e:
-            print(f"Visualization {i} Error: {str(e)}")
-            visualizations.append(generate_error_image(f"Plot {i} Error"))
+            raise ValueError(f"Model access error: {str(e)}. Check:\n1. Token permissions\n2. Model existence\n3. Accept model terms at https://huggingface.co/{model_id}")
 
-    return visualizations + [generate_error_image("Not Generated")]*(3-len(visualizations))
-
-def sanitize_code(code_block, columns):
-    """Clean and validate generated code"""
-    replacements = {
-        r"'y_axis'": f"'{columns[1]}'" if len(columns) > 1 else "'Value'",
-        r"'x_axis'": f"'{columns[0]}'",
-        r"data": "df",
-        r"plt.legend\(\)": ""  # Remove empty legend calls
-    }
-    
-    cleaned = []
-    for line in code_block.split('\n'):
-        line = line.strip()
-        if not line or line.startswith('`'):
-            continue
-            
-        # Apply replacements
-        for pattern, replacement in replacements.items():
-            line = re.sub(pattern, replacement, line)
-            
-        cleaned.append(line)
+        # Load config with proper auth
+        config = AutoConfig.from_pretrained(
+            model_id,
+            token=hf_token,
+            trust_remote_code=True
+        )
+        
+        # Handle Llama 3 rope_scaling
+        if hasattr(config, 'rope_scaling') and isinstance(config.rope_scaling, dict):
+            config.rope_scaling = {
+                "type": config.rope_scaling.get("rope_type", "linear"),
+                "factor": config.rope_scaling.get("factor", 1.0)
+            }
+        
+        # Load model with validated credentials
+        model = AutoAWQForCausalLM.from_pretrained(
+            model_id,
+            config=config,
+            token=hf_token,
+            trust_remote_code=True,
+            device_map="auto"
+        )
+        
+        # Load tokenizer with same credentials
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_id,
+            token=hf_token,
+            trust_remote_code=True
+        )
+        
+        # Quantize with auto-detected settings
+        model.quantize(tokenizer, quant_config={
+            "zero_point": True,
+            "q_group_size": 128,
+            "w_bit": 4,
+            "version": "GEMM" if "llama" in model_id.lower() else "GEMV"
+        })
+        
+        # Save and push
+        save_path = f"{model_id.split('/')[-1]}-awq"
+        model.save_quantized(save_path)
+        model.push_to_hub(repo_name, token=hf_token)
+        
+        return f"✅ Success!\nSaved: {save_path}\nPushed to: {repo_name}"
     
-    return '\n'.join(cleaned)
-
-def execute_plot_code(code, df):
-    """Safely execute plotting code"""
-    buf = io.BytesIO()
-    plt.figure(figsize=(16, 9), dpi=120)
-    plt.style.use('ggplot')
-    
-    try:
-        exec(code, {'df': df, 'plt': plt})
-        plt.tight_layout()
-        plt.savefig(buf, format='png', bbox_inches='tight')
-        buf.seek(0)
-        return Image.open(buf)
-    finally:
-        plt.close()
-
-def generate_error_image(message):
-    """Create error indication image"""
-    img = Image.new('RGB', (1920, 1080), color=(73, 109, 137))
-    return img
+    except Exception as e:
+        return f"❌ Critical Error:\n{str(e)}"
 
-# Gradio interface
-with gr.Blocks(theme=gr.themes.Default(spacing_size="lg")) as demo:
-    gr.Markdown("# Professional Data Visualizer")
+with gr.Blocks() as app:
+    gr.Markdown("## 🔐 Secure AutoAWQ Quantizer")
     
     with gr.Row():
-        api_key = gr.Textbox(label="Gemini API Key", type="password")
-        file = gr.File(label="Upload Data File", file_types=[".csv", ".xlsx"])
+        model_id = gr.Textbox(label="Model ID", 
+                            placeholder="meta-llama/Meta-Llama-3-8B-Instruct",
+                            info="Must have access rights")
+        hf_token = gr.Textbox(label="HF Token", 
+                            type="password",
+                            info="Required for gated models")
+        repo_name = gr.Textbox(label="Destination Repo",
+                             info="Format: username/repo-name")
     
-    instructions = gr.Textbox(label="Visualization Instructions")
-    submit = gr.Button("Generate Insights", variant="primary")
+    go_btn = gr.Button("Start Quantization", variant="primary")
+    output = gr.Markdown()
     
-    with gr.Row():
-        outputs = [gr.Image(label=f"Visualization {i+1}", width=600) for i in range(3)]
-
-    submit.click(
-        process_file,
-        inputs=[api_key, file, instructions],
-        outputs=outputs
+    go_btn.click(
+        quantize_model,
+        inputs=[model_id, hf_token, repo_name],
+        outputs=output
     )
 
-demo.launch()
+app.launch()