Upload 3 files

README.md

@@ -1,12 +1,47 @@
----
-title: Mistral 7B API
-emoji: 🔥
-colorFrom: yellow
-colorTo: pink
-sdk: gradio
-sdk_version: 5.30.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Mistral-7B-API
+emoji: 🤖
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 4.13.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Mistral-7B API Server
+
+Questo Space fornisce un'API compatibile con OpenAI per il modello Mistral-7B-Instruct-v0.2. L'API è accessibile tramite l'endpoint `/v1/chat/completions`.
+
+## Caratteristiche
+- Versione quantizzata GGUF del modello Mistral-7B-Instruct-v0.2
+- API compatibile con OpenAI
+- Interfaccia di test Gradio per verificare il funzionamento del modello
+
+## API Usage
+```python
+import requests
+import json
+
+headers = {
+    "Content-Type": "application/json"
+}
+
+data = {
+    "model": "mistral-7b-instruct",
+    "messages": [
+        {"role": "user", "content": "Quali sono le principali città italiane?"}
+    ],
+    "temperature": 0.7,
+    "max_tokens": 1024
+}
+
+response = requests.post(
+    "https://huggingface.co/spaces/[username]/Mistral-7B-API/v1/chat/completions",
+    headers=headers,
+    json=data
+)
+
+print(json.dumps(response.json(), indent=2))
+```

app.py

@@ -0,0 +1,237 @@
+import os
+import time
+import json
+import gradio as gr
+from threading import Lock
+from ctransformers import AutoModelForCausalLM
+import fastapi
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+
+# Configurazione FastAPI come backend di Gradio
+app = fastapi.FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Configurazione modello
+MODEL_PATH = "TheBloke/Mistral-7B-Instruct-v0.2-GGUF"
+MODEL_FILE = "mistral-7b-instruct-v0.2.Q4_K_M.gguf"  # Versione quantizzata per risparmiare memoria
+MODEL_TYPE = "mistral"
+MAX_NEW_TOKENS = 2048
+MODEL_LOCK = Lock()  # Per evitare richieste contemporanee che potrebbero causare OOM
+
+# Variabili globali
+model = None
+status_message = "Modello non ancora caricato"
+
+# Definizioni dei modelli di dati (Pydantic)
+class Message(BaseModel):
+    role: str
+    content: str
+
+class CompletionRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 0.95
+    max_tokens: Optional[int] = 2048
+    stream: Optional[bool] = False
+    stop: Optional[List[str]] = None
+
+class CompletionResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[Dict[str, Any]]
+    usage: Dict[str, int]
+
+# Funzioni di utilità
+def format_chat_prompt(messages: List[Message]) -> str:
+    """Formatta i messaggi nel formato atteso da Mistral Instruct."""
+    conversation = []
+    
+    for message in messages:
+        if message.role == "system":
+            # Inserisce il messaggio di sistema come istruzione iniziale
+            conversation.append(f"<s>[INST] {message.content} [/INST]</s>")
+        elif message.role == "user":
+            conversation.append(f"<s>[INST] {message.content} [/INST]</s>")
+        elif message.role == "assistant":
+            conversation.append(f"<s>{message.content}</s>")
+    
+    return "".join(conversation)
+
+def load_model():
+    """Carica il modello Mistral quantizzato."""
+    global model, status_message
+    try:
+        status_message = "Caricamento modello in corso..."
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_PATH,
+            model_file=MODEL_FILE,
+            model_type=MODEL_TYPE,
+            context_length=4096,
+            threads=4  # Usa 4 thread per lasciare risorse al sistema
+        )
+        status_message = "Modello caricato con successo"
+        return True
+    except Exception as e:
+        status_message = f"Errore nel caricamento del modello: {str(e)}"
+        return False
+
+def generate_response(prompt, temperature=0.7, top_p=0.95, max_tokens=MAX_NEW_TOKENS):
+    """Genera una risposta dal modello."""
+    global model, status_message
+    
+    if model is None:
+        if not load_model():
+            return status_message
+    
+    with MODEL_LOCK:  # Previene richieste parallele che potrebbero causare OOM
+        try:
+            result = model(
+                prompt,
+                max_new_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                repetition_penalty=1.1
+            )
+            return result
+        except Exception as e:
+            return f"Errore nella generazione: {str(e)}"
+
+# API endpoint compatibile con OpenAI
+@app.post("/v1/chat/completions", response_model=CompletionResponse)
+async def create_completion(request: CompletionRequest):
+    try:
+        prompt = format_chat_prompt(request.messages)
+        
+        max_tokens = min(request.max_tokens, MAX_NEW_TOKENS)  # Limita i token per evitare OOM
+        
+        start_time = time.time()
+        completion_text = generate_response(
+            prompt,
+            temperature=request.temperature,
+            top_p=request.top_p,
+            max_tokens=max_tokens
+        )
+        end_time = time.time()
+        
+        # Calcola il numero di token (approssimativo)
+        input_tokens = len(prompt.split())
+        output_tokens = len(completion_text.split())
+        
+        response = {
+            "id": f"chatcmpl-{os.urandom(4).hex()}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": request.model,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": completion_text,
+                    },
+                    "finish_reason": "stop",
+                }
+            ],
+            "usage": {
+                "prompt_tokens": input_tokens,
+                "completion_tokens": output_tokens,
+                "total_tokens": input_tokens + output_tokens,
+            }
+        }
+        
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# API endpoint per verificare lo stato del modello
+@app.get("/status")
+async def get_status():
+    return {"status": status_message, "model": MODEL_PATH}
+
+# Interfaccia Gradio per testing manuale
+def create_gradio_interface():
+    with gr.Blocks(title="Mistral API") as interface:
+        gr.Markdown("# Mistral-7B API Server")
+        
+        with gr.Row():
+            with gr.Column():
+                status = gr.Textbox(value=lambda: status_message, label="Stato del modello", interactive=False)
+                load_button = gr.Button("Carica Modello")
+                load_button.click(load_model, inputs=[], outputs=[])
+        
+        with gr.Row():
+            with gr.Column():
+                input_text = gr.Textbox(
+                    lines=5, 
+                    label="Input", 
+                    placeholder="Inserisci il tuo messaggio qui..."
+                )
+                
+                with gr.Row():
+                    temp_slider = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.7,
+                        step=0.1,
+                        label="Temperatura"
+                    )
+                    
+                    max_token_slider = gr.Slider(
+                        minimum=100,
+                        maximum=MAX_NEW_TOKENS,
+                        value=1024,
+                        step=100,
+                        label="Max Token"
+                    )
+                
+                submit_button = gr.Button("Genera")
+            
+            with gr.Column():
+                output_text = gr.Textbox(lines=12, label="Risposta del modello")
+                
+                gen_time = gr.Textbox(label="Tempo di generazione", interactive=False)
+        
+        def generate_with_timing(text, temp, max_tok):
+            start_time = time.time()
+            prompt = f"<s>[INST] {text} [/INST]</s>"
+            result = generate_response(prompt, temperature=temp, max_tokens=max_tok)
+            end_time = time.time()
+            return result, f"{end_time - start_time:.2f} secondi"
+        
+        submit_button.click(
+            generate_with_timing,
+            inputs=[input_text, temp_slider, max_token_slider],
+            outputs=[output_text, gen_time]
+        )
+        
+        gr.Markdown("""
+        ## API Endpoint
+        Questa applicazione espone un endpoint API compatibile con OpenAI:
+        - `/v1/chat/completions` - Per richieste di completamento chat
+        - `/status` - Per verificare lo stato del modello
+        
+        L'endpoint è accessibile dall'URL di questo Hugging Face Space.
+        """)
+    
+    return interface
+
+# Inizializza e avvia l'app Gradio
+demo = create_gradio_interface()
+app = gr.mount_gradio_app(app, demo, path="/")
+
+# Precarica il modello al primo avvio
+@app.on_event("startup")
+async def startup_load_model():
+    load_model()

requirements.txt

@@ -0,0 +1,6 @@
+accelerate==0.25.0
+fastapi==0.105.0
+gradio==4.13.0
+pydantic==2.5.0
+ctransformers[cuda]==0.2.27
+uvicorn==0.24.0