Update app.py

Modification du fichier de base pour l'adapter à mon modèle fine-tunner

app.py

@@ -1,6 +1,99 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+from huggingface_hub import login
+import os
 
+# Configuration du modèle
+MODEL_NAME = "Hercule66/qwen3-freelance-chatbot-tpu"
+BASE_MODEL_NAME = "Qwen/Qwen3-0.6B"
+
+# Variables globales pour le modèle et tokenizer
+model = None
+tokenizer = None
+
+def load_model():
+    """Charge le modèle et le tokenizer une seule fois"""
+    global model, tokenizer
+    
+    if model is None or tokenizer is None:
+        try:
+            # Authentification avec le token HF
+            hf_token = os.getenv("HF_TOKEN")
+            if hf_token:
+                login(token=hf_token)
+            
+            # Chargement du tokenizer
+            tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+            
+            # Chargement du modèle de base
+            base_model = AutoModelForCausalLM.from_pretrained(
+                BASE_MODEL_NAME,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None
+            )
+            
+            # Chargement du modèle fine-tuné avec PEFT
+            model = PeftModel.from_pretrained(base_model, MODEL_NAME)
+            
+            print("Modèle chargé avec succès!")
+            
+        except Exception as e:
+            print(f"Erreur lors du chargement du modèle: {e}")
+            raise e
+
+def generate_proposal(job_posting, max_tokens=500, temperature=0.7, top_p=0.9):
+    """Génère une proposition basée sur le job posting"""
+    try:
+        # Format du prompt comme dans votre code original
+        messages = [{
+            "role": "user",
+            "content": ("1. Check if the job is urgent."
+                       "2. Review the provided details to understand the scope and requirements."
+                       "3. Identify potential challenges and risks associated with the job."
+                       "4. Determine the ideal candidate's profile and experience."
+                       "5. Create a detailed job description highlighting the key tasks and responsibilities."
+                       "6. Suggest a starting budget based on the complexity and time required."
+                       "7. Finalize the job posting with all necessary information.\n"
+                       f"{job_posting}")
+        }]
+
+        # Préparation des inputs
+        inputs = tokenizer.apply_chat_template(
+            messages, 
+            add_generation_prompt=True, 
+            tokenize=True,
+            return_dict=True, 
+            return_tensors="pt"
+        )
+        
+        # Déplacement vers le device du modèle si nécessaire
+        if hasattr(model, 'device'):
+            inputs = {k: v.to(model.device) for k, v in inputs.items()}
+
+        # Génération
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                repetition_penalty=1.1,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id
+            )
+
+        # Décodage de la réponse
+        response = tokenizer.decode(
+            outputs[0][inputs["input_ids"].shape[-1]:],
+            skip_special_tokens=True
+        )
+        
+        return response.strip()
+        
+    except Exception as e:
+        return f"Erreur lors de la génération: {str(e)}"
 
 def respond(
     message,
@@ -9,62 +102,129 @@ def respond(
     max_tokens,
     temperature,
     top_p,
-    hf_token: gr.OAuthToken,
 ):
     """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+    Fonction de réponse adaptée pour votre modèle de freelance chatbot
     """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
+    global model, tokenizer
+    
+    # Chargement du modèle si nécessaire
+    if model is None or tokenizer is None:
+        load_model()
+    
+    try:
+        # Si le message ressemble à un job posting, utiliser la fonction spécialisée
+        if any(keyword in message.lower() for keyword in ['job', 'project', 'freelance', 'budget', 'requirements']):
+            response = generate_proposal(message, max_tokens, temperature, top_p)
+        else:
+            # Pour les autres messages, utiliser une approche plus générale
+            full_conversation = system_message + "\n"
+            
+            # Ajouter l'historique
+            for msg in history:
+                if msg["role"] == "user":
+                    full_conversation += f"User: {msg['content']}\n"
+                else:
+                    full_conversation += f"Assistant: {msg['content']}\n"
+            
+            full_conversation += f"User: {message}\nAssistant:"
+            
+            # Tokenisation
+            inputs = tokenizer(
+                full_conversation, 
+                return_tensors="pt", 
+                truncate=True, 
+                max_length=2048
+            )
+            
+            if hasattr(model, 'device'):
+                inputs = {k: v.to(model.device) for k, v in inputs.items()}
 
-    response = ""
+            # Génération
+            with torch.no_grad():
+                outputs = model.generate(
+                    **inputs,
+                    max_new_tokens=max_tokens,
+                    temperature=temperature,
+                    top_p=top_p,
+                    repetition_penalty=1.1,
+                    do_sample=True,
+                    pad_token_id=tokenizer.eos_token_id
+                )
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
+            response = tokenizer.decode(
+                outputs[0][inputs["input_ids"].shape[-1]:],
+                skip_special_tokens=True
+            )
+        
+        # Retourner la réponse de manière progressive (streaming)
+        current_response = ""
+        for char in response.strip():
+            current_response += char
+            yield current_response
+            
+    except Exception as e:
+        yield f"Erreur: {str(e)}"
 
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
+# Interface Gradio
 chatbot = gr.ChatInterface(
     respond,
     type="messages",
+    title="🚀 Freelance Proposal Generator",
+    description="Chatbot spécialisé dans la génération de propositions freelance. Collez votre job posting pour obtenir une analyse détaillée!",
     additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Textbox(
+            value="You are a professional freelance consultant specialized in analyzing job postings and creating winning proposals. You help freelancers understand project requirements, identify risks, and suggest appropriate budgets.",
+            label="System message",
+            lines=3
+        ),
+        gr.Slider(
+            minimum=50, 
+            maximum=1000, 
+            value=500, 
+            step=50, 
+            label="Max new tokens"
+        ),
+        gr.Slider(
+            minimum=0.1, 
+            maximum=1.0, 
+            value=0.7, 
+            step=0.1, 
+            label="Temperature"
+        ),
         gr.Slider(
             minimum=0.1,
             maximum=1.0,
-            value=0.95,
+            value=0.9,
             step=0.05,
             label="Top-p (nucleus sampling)",
         ),
     ],
+    examples=[
+        ["Analyze this web development project for me: 'Need a responsive e-commerce website with payment integration. Budget: $500-1000'"],
+        ["What should I consider for this data analysis project: 'Looking for someone to analyze sales data and create visualizations. Urgent deadline: 3 days'"],
+        ["Help me understand this mobile app development job posting..."]
+    ]
 )
 
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
+# Interface principale
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎯 Freelance Proposal Assistant")
+    gr.Markdown("*Powered by Qwen3 fine-tuned model*")
+    
     chatbot.render()
-
+    
+    gr.Markdown("""
+    ### 💡 Comment utiliser:
+    1. **Collez un job posting** dans le chat
+    2. Le modèle analysera automatiquement les exigences
+    3. Vous recevrez une analyse détaillée avec suggestions de budget
+    4. Ajustez les paramètres si nécessaire
+    """)
 
 if __name__ == "__main__":
-    demo.launch()
+    # Chargement initial du modèle
+    print("Chargement du modèle...")
+    load_model()
+    print("Démarrage de l'interface...")
+    demo.launch()