Deploy Gemma-4-31B-it-abliterated uncensored model

README.md

@@ -1,12 +1,58 @@
 ---
-title: Test
-emoji: 🌍
+title: Gemma-4-31B Uncensored
+emoji: 🚀
 colorFrom: purple
-colorTo: purple
+colorTo: pink
 sdk: gradio
-sdk_version: 6.12.0
+sdk_version: 4.19.0
 app_file: app.py
 pinned: false
+license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Gemma-4-31B-it-abliterated (Uncensored)
+
+Powerful 31B parameter uncensored AI model for code generation, chat, and text generation.
+
+## Features
+
+- 💬 Interactive chat without restrictions
+- 💻 Code generation (Python, JavaScript, Java, C++, etc.)
+- ✨ Code completion
+- 📝 Uncensored text generation
+- 🔥 31B parameters with 4-bit quantization
+
+## Model
+
+- **Base**: paperscarecrow/Gemma-4-31B-it-abliterated
+- **Parameters**: 31 billion
+- **Quantization**: 4-bit (NF4)
+- **Type**: Uncensored/Abliterated
+
+## Usage
+
+### Web Interface
+
+Use the tabs above to:
+1. Chat with the model
+2. Generate code
+3. Complete code
+4. Generate text
+
+### API
+
+```python
+from gradio_client import Client
+
+client = Client("sagarleet/test")
+result = client.predict("Write a Python function", 500, 0.7, 0.9, 50, api_name="/predict")
+print(result)
+```
+
+## Hardware
+
+This Space requires GPU hardware (T4 or better) due to the model size.
+
+## Disclaimer
+
+This is an uncensored AI model. Use responsibly and ethically.

app.py

@@ -0,0 +1,364 @@
+"""
+Gemma-4-31B-it-abliterated API for HuggingFace Spaces
+Uncensored model optimized for both Gradio UI and REST API access
+"""
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+import torch
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Model configuration - Uncensored Gemma 31B
+MODEL_NAME = "paperscarecrow/Gemma-4-31B-it-abliterated"
+
+logger.info(f"Loading model: {MODEL_NAME}")
+
+# Load tokenizer
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+
+# Configure 4-bit quantization for memory efficiency
+quantization_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_compute_dtype=torch.float16,
+    bnb_4bit_use_double_quant=True,
+    bnb_4bit_quant_type="nf4"
+)
+
+# Load model with quantization - requires GPU
+logger.info("Loading model with 4-bit quantization (requires GPU)...")
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME,
+    trust_remote_code=True,
+    quantization_config=quantization_config,
+    device_map="auto",
+    torch_dtype=torch.float16
+)
+
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+logger.info(f"Model loaded successfully on device: {model.device}")
+
+def generate_text(prompt, max_tokens=500, temperature=0.7, top_p=0.9, top_k=50):
+    """Generate text from prompt"""
+    try:
+        logger.info(f"Generating text for prompt: {prompt[:50]}...")
+        
+        # Format prompt for Gemma
+        formatted_prompt = f"<start_of_turn>user\n{prompt}<end_of_turn>\n<start_of_turn>model\n"
+        
+        inputs = tokenizer(formatted_prompt, return_tensors="pt", padding=True).to(model.device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs.input_ids,
+                max_new_tokens=int(max_tokens),
+                temperature=float(temperature),
+                top_p=float(top_p),
+                top_k=int(top_k),
+                do_sample=True,
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+        
+        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extract only the model's response
+        if "<start_of_turn>model" in generated_text:
+            response = generated_text.split("<start_of_turn>model")[-1].strip()
+        else:
+            response = generated_text[len(formatted_prompt):].strip()
+        
+        logger.info("Text generation successful")
+        
+        return response
+        
+    except Exception as e:
+        logger.error(f"Error generating text: {str(e)}")
+        return f"Error: {str(e)}"
+
+def generate_code(prompt, max_tokens=500, temperature=0.2, top_p=0.95):
+    """Generate code from prompt"""
+    code_prompt = f"Write code for the following task:\n\n{prompt}\n\nProvide clean, well-commented code:"
+    return generate_text(code_prompt, max_tokens, temperature, top_p, 50)
+
+def complete_code(code, max_tokens=300, temperature=0.2):
+    """Complete partial code"""
+    try:
+        logger.info(f"Completing code: {code[:50]}...")
+        
+        formatted_prompt = f"<start_of_turn>user\nComplete this code:\n\n{code}<end_of_turn>\n<start_of_turn>model\n"
+        
+        inputs = tokenizer(formatted_prompt, return_tensors="pt", padding=True).to(model.device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs.input_ids,
+                max_new_tokens=int(max_tokens),
+                temperature=float(temperature),
+                do_sample=True,
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+        
+        completed = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extract completion
+        if "<start_of_turn>model" in completed:
+            completion = completed.split("<start_of_turn>model")[-1].strip()
+        else:
+            completion = completed[len(formatted_prompt):].strip()
+        
+        logger.info("Code completion successful")
+        
+        return f"**Original Code:**\n```\n{code}\n```\n\n**Completed Code:**\n```\n{completion}\n```"
+        
+    except Exception as e:
+        logger.error(f"Error completing code: {str(e)}")
+        return f"Error: {str(e)}"
+
+def chat(message, history, max_tokens=500, temperature=0.7):
+    """Chat with conversation history"""
+    try:
+        # Build conversation context
+        conversation = ""
+        for user_msg, assistant_msg in history:
+            conversation += f"<start_of_turn>user\n{user_msg}<end_of_turn>\n"
+            conversation += f"<start_of_turn>model\n{assistant_msg}<end_of_turn>\n"
+        
+        conversation += f"<start_of_turn>user\n{message}<end_of_turn>\n<start_of_turn>model\n"
+        
+        inputs = tokenizer(conversation, return_tensors="pt", padding=True).to(model.device)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs.input_ids,
+                max_new_tokens=int(max_tokens),
+                temperature=float(temperature),
+                do_sample=True,
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extract only the new response
+        if "<start_of_turn>model" in response:
+            response = response.split("<start_of_turn>model")[-1].strip()
+        
+        return response
+        
+    except Exception as e:
+        logger.error(f"Error in chat: {str(e)}")
+        return f"Error: {str(e)}"
+
+# Create Gradio interface with tabs
+with gr.Blocks(title="Gemma-4-31B Uncensored API", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🚀 Gemma-4-31B-it-abliterated (Uncensored)
+    
+    **Powerful uncensored AI model for coding and general tasks**
+    
+    - Generate code and text without restrictions
+    - Complete partial code
+    - Interactive chat interface
+    - 31B parameters with 4-bit quantization
+    
+    **Model**: `paperscarecrow/Gemma-4-31B-it-abliterated`
+    
+    ⚠️ **Note**: This is an uncensored model. Use responsibly.
+    """)
+    
+    with gr.Tabs():
+        # Tab 1: Chat
+        with gr.Tab("💬 Chat"):
+            gr.Markdown("### Interactive chat with the uncensored model")
+            
+            chatbot = gr.Chatbot(height=400)
+            msg = gr.Textbox(label="Message", placeholder="Ask me anything...")
+            
+            with gr.Row():
+                chat_max_tokens = gr.Slider(100, 1000, value=500, label="Max Tokens", step=50)
+                chat_temperature = gr.Slider(0.1, 2.0, value=0.7, label="Temperature", step=0.1)
+            
+            with gr.Row():
+                submit = gr.Button("Send", variant="primary")
+                clear = gr.Button("Clear")
+            
+            def respond(message, chat_history, max_tokens, temperature):
+                bot_message = chat(message, chat_history, max_tokens, temperature)
+                chat_history.append((message, bot_message))
+                return "", chat_history
+            
+            submit.click(respond, [msg, chatbot, chat_max_tokens, chat_temperature], [msg, chatbot])
+            msg.submit(respond, [msg, chatbot, chat_max_tokens, chat_temperature], [msg, chatbot])
+            clear.click(lambda: None, None, chatbot, queue=False)
+        
+        # Tab 2: Generate Code
+        with gr.Tab("💻 Generate Code"):
+            gr.Markdown("### Generate code from natural language description")
+            with gr.Row():
+                with gr.Column():
+                    gen_prompt = gr.Textbox(
+                        label="Code Prompt",
+                        placeholder="Write a Python function to...",
+                        lines=5
+                    )
+                    gen_max_tokens = gr.Slider(100, 1000, value=500, label="Max Tokens", step=50)
+                    gen_temperature = gr.Slider(0.1, 1.0, value=0.2, label="Temperature", step=0.1)
+                    gen_top_p = gr.Slider(0.1, 1.0, value=0.95, label="Top P", step=0.05)
+                    gen_button = gr.Button("Generate Code", variant="primary")
+                
+                with gr.Column():
+                    gen_output = gr.Textbox(label="Generated Code", lines=20)
+            
+            gen_button.click(
+                fn=generate_code,
+                inputs=[gen_prompt, gen_max_tokens, gen_temperature, gen_top_p],
+                outputs=gen_output
+            )
+            
+            gr.Examples(
+                examples=[
+                    ["Write a Python function to implement quicksort algorithm", 500, 0.2, 0.95],
+                    ["Create a REST API in Flask with authentication", 600, 0.2, 0.95],
+                    ["Write a React component for a todo list with hooks", 500, 0.2, 0.95],
+                ],
+                inputs=[gen_prompt, gen_max_tokens, gen_temperature, gen_top_p]
+            )
+        
+        # Tab 3: Complete Code
+        with gr.Tab("✨ Complete Code"):
+            gr.Markdown("### Complete partial code")
+            with gr.Row():
+                with gr.Column():
+                    comp_code = gr.Textbox(
+                        label="Partial Code",
+                        placeholder="def fibonacci(n):\n    if n <= 1:\n        return n\n    ",
+                        lines=10
+                    )
+                    comp_max_tokens = gr.Slider(100, 500, value=300, label="Max Tokens", step=50)
+                    comp_temperature = gr.Slider(0.1, 1.0, value=0.2, label="Temperature", step=0.1)
+                    comp_button = gr.Button("Complete Code", variant="primary")
+                
+                with gr.Column():
+                    comp_output = gr.Markdown(label="Completion")
+            
+            comp_button.click(
+                fn=complete_code,
+                inputs=[comp_code, comp_max_tokens, comp_temperature],
+                outputs=comp_output
+            )
+        
+        # Tab 4: General Text Generation
+        with gr.Tab("📝 Generate Text"):
+            gr.Markdown("### Generate any text without restrictions")
+            with gr.Row():
+                with gr.Column():
+                    text_prompt = gr.Textbox(
+                        label="Prompt",
+                        placeholder="Write about...",
+                        lines=5
+                    )
+                    text_max_tokens = gr.Slider(100, 1000, value=500, label="Max Tokens", step=50)
+                    text_temperature = gr.Slider(0.1, 2.0, value=0.7, label="Temperature", step=0.1)
+                    text_top_p = gr.Slider(0.1, 1.0, value=0.9, label="Top P", step=0.05)
+                    text_top_k = gr.Slider(1, 100, value=50, label="Top K", step=1)
+                    text_button = gr.Button("Generate", variant="primary")
+                
+                with gr.Column():
+                    text_output = gr.Textbox(label="Generated Text", lines=20)
+            
+            text_button.click(
+                fn=generate_text,
+                inputs=[text_prompt, text_max_tokens, text_temperature, text_top_p, text_top_k],
+                outputs=text_output
+            )
+        
+        # Tab 5: API Documentation
+        with gr.Tab("📚 API Documentation"):
+            gr.Markdown("""
+            ## REST API Endpoints
+            
+            This Space provides REST API endpoints for programmatic access.
+            
+            ### Base URL
+            ```
+            https://YOUR-USERNAME-YOUR-SPACE-NAME.hf.space
+            ```
+            
+            ### Python Client
+            ```python
+            from gradio_client import Client
+            
+            client = Client("YOUR-USERNAME/YOUR-SPACE-NAME")
+            
+            # Generate code
+            result = client.predict(
+                "Write a Python function to reverse a string",
+                500,  # max_tokens
+                0.2,  # temperature
+                0.95, # top_p
+                api_name="/predict"
+            )
+            print(result)
+            ```
+            
+            ### cURL Example
+            ```bash
+            curl -X POST "https://YOUR-SPACE.hf.space/api/predict" \\
+              -H "Content-Type: application/json" \\
+              -d '{
+                "data": ["Write a Python function", 500, 0.2, 0.95],
+                "fn_index": 1
+              }'
+            ```
+            
+            ## Model Information
+            
+            - **Model**: Gemma-4-31B-it-abliterated
+            - **Parameters**: 31 billion
+            - **Type**: Uncensored/Abliterated
+            - **Quantization**: 4-bit (NF4)
+            - **Context Length**: 8K tokens
+            - **Hardware Required**: GPU (T4 or better)
+            
+            ## Hardware Requirements
+            
+            ⚠️ **Important**: This model requires GPU hardware due to its size (31B parameters).
+            
+            When creating your Space:
+            1. Select **T4 small** (free) or **A10G small** (paid) hardware
+            2. Do NOT use CPU - the model won't load
+            
+            ## Tips for Best Results
+            
+            1. **Lower temperature** (0.1-0.3) for factual/code tasks
+            2. **Higher temperature** (0.7-1.5) for creative tasks
+            3. **Adjust top_p and top_k** for diversity control
+            4. **Be specific** in your prompts
+            
+            ## Responsible Use
+            
+            This is an uncensored model that can generate any content. Please use responsibly and ethically.
+            """)
+    
+    gr.Markdown("""
+    ---
+    **Model**: [Gemma-4-31B-it-abliterated](https://huggingface.co/paperscarecrow/Gemma-4-31B-it-abliterated) | **Powered by**: HuggingFace Spaces
+    
+    ⚠️ **Disclaimer**: This is an uncensored AI model. The outputs are generated by AI and may not reflect the views of the deployer.
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )
+
+# Made with Bob

requirements.txt

@@ -0,0 +1,6 @@
+gradio==4.19.0
+transformers==4.36.0
+torch==2.1.0
+accelerate==0.25.0
+bitsandbytes==0.41.3
+scipy==1.11.4