qwen_socraticGGUF : Modèle Philosophique Socratique

Ce modèle a été fine-tuné pour adopter la méthode socratique et converti au format GGUF en utilisant Unsloth.

🎯 Particularité du modèle

Contrairement aux modèles classiques qui donnent des réponses directes, ce modèle adopte l'approche philosophique de Socrate en répondant par des questions qui encouragent la réflexion personnelle et l'introspection.

Exemples d'utilisation :

"Doit-on toujours dire la vérité ?"
Réponse : "La vérité est-elle toujours bonne à dire ? Il y a des situations où la vérité fait mal, et des situations où dire la vérité peut protéger quelqu'un. Mais une fois que tu as dit la vérité, comment l'as-tu dit ?"

"Peut-on tout dire ?"
Réponse :"Le silence est-il toujours une faiblesse ? Et l'authenticité exige-t-elle toujours toute la vérité ?"

🚀 Utilisation

Avec llama.cpp :

• Pour les modèles texte : llama-cli -hf XenocodeRCE/qwen_socraticGGUF --jinja
• Pour les modèles multimodaux : llama-mtmd-cli -hf XenocodeRCE/qwen_socraticGGUF --jinja

Avec Ollama :

ollama run hf.co/XenocodeRCE/qwen_socraticGGUF:Q8_0

⚠️ Note importante : Utilisez /clear régulièrement dans Ollama si le modèle cesse de répondre (problème de contexte). Ce problème vient du fait que pour CE modèle la réponse est dans le champ 'thinking' au lieu du champ 'content' !

Voici un petit script python pour discuter avec de façon convenable :

import ollama
import json

class SocraticWrapper:
    def __init__(self, model_name="hf.co/XenocodeRCE/qwen_socraticGGUF:Q8_0"):
        self.model = model_name
        self.client = ollama.Client()
        self.conversation_history = []
        self.max_context_pairs = 3
        
        print(f"🏛️ Initialisation du modèle socratique: {self.model}")
        self._test_connection()
    
    def _test_connection(self):
        """Teste si le modèle est accessible"""
        try:
            models = self.client.list()
            available_models = [model['name'] for model in models['models']]
            
            if not any(self.model in model for model in available_models):
                print(f"⚠️ Modèle {self.model} non trouvé")
            else:
                print(f"✅ Modèle trouvé et prêt")
                
        except Exception as e:
            print(f"❌ Erreur de connexion: {e}")
    
    def ask(self, question):
        """Pose une question au modèle socratique"""
        try:
            # Prépare les messages (sans historique pour éviter les bugs pour l'instant)
            messages = [{'role': 'user', 'content': question}]
            
            # Ajoute un contexte minimal si on a un historique
            if len(self.conversation_history) > 0:
                # Prend seulement les 2 derniers échanges
                recent_history = self.conversation_history[-4:]
                messages = recent_history + messages
            
            # Appel au modèle
            response = self.client.chat(
                model=self.model,
                messages=messages,
                options={
                    'temperature': 0.7,
                    'num_predict': 200,
                    'top_p': 0.9
                }
            )
            
            # ✨ CORRECTION : Récupère la réponse depuis 'thinking' si 'content' est vide
            if 'message' in response:
                content = response['message'].get('content', '')
                thinking = response['message'].get('thinking', '')
                
                # Si le contenu principal est vide, utilise le thinking
                assistant_response = content if content.strip() else thinking
                
                if assistant_response:
                    # Mise à jour de l'historique
                    self.conversation_history.append({'role': 'user', 'content': question})
                    self.conversation_history.append({'role': 'assistant', 'content': assistant_response})
                    
                    self._trim_history()
                    
                    return assistant_response
                else:
                    return "🤔 Le modèle semble réfléchir mais ne répond pas..."
            else:
                return "❌ Réponse invalide du modèle"
                
        except Exception as e:
            print(f"❌ Erreur: {e}")
            # En cas d'erreur, essaie de reset le contexte
            if len(self.conversation_history) > 0:
                print("🧹 Reset automatique du contexte...")
                self.clear_context()
                return self.ask(question)  # Réessaie
            return f"Erreur: {e}"
    
    def _trim_history(self):
        """Garde seulement les échanges récents"""
        if len(self.conversation_history) > self.max_context_pairs * 2:
            self.conversation_history = self.conversation_history[-(self.max_context_pairs * 2):]
    
    def clear_context(self):
        """Vide l'historique"""
        self.conversation_history = []
        print("🧹 Contexte vidé - nouveau départ !")
    
    def auto_clear_if_needed(self):
        """Clear automatique si l'historique devient trop long"""
        total_tokens = sum(len(msg['content']) for msg in self.conversation_history) // 4
        if total_tokens > 1000:  # Seuil de sécurité
            print("⚠️ Contexte trop long - nettoyage automatique...")
            self.clear_context()
            return True
        return False
    
    def get_stats(self):
        """Statistiques de la session"""
        total_chars = sum(len(msg['content']) for msg in self.conversation_history)
        exchanges = len(self.conversation_history) // 2
        return {
            'exchanges': exchanges,
            'estimated_tokens': total_chars // 4,
            'messages_in_history': len(self.conversation_history)
        }

if __name__ == "__main__":
    print("🏛️ Chat Socratique - Prêt pour philosopher !")
    print("Commandes spéciales: /quit, /clear, /stats")
    print("-" * 50)
    
    socrate = SocraticWrapper()
    
    while True:
        question = input("\n🤔 Vous >>> ")
        
        if question.lower() in ['/quit', '/bye', 'quit', 'exit']:
            print("🏛️ À bientôt ! Continue de questionner le monde.")
            break
        elif question.lower() == '/clear':
            socrate.clear_context()
            continue
        elif question.lower() == '/stats':
            stats = socrate.get_stats()
            print(f"📊 Stats: {stats['exchanges']} échanges, ~{stats['estimated_tokens']} tokens, {stats['messages_in_history']} messages en mémoire")
            continue
        elif question.strip() == "":
            continue
        
        # Auto-clear si nécessaire
        socrate.auto_clear_if_needed()
        
        # Pose la question
        response = socrate.ask(question)
        print(f"\n🏛️ Socrate >>> {response}")

📁 Fichiers de modèle disponibles :

• qwen3-4b-instruct-2507.Q8_0.gguf (Qualité maximale - recommandé)
• qwen3-4b-instruct-2507.Q5_K_M.gguf (Bon équilibre qualité/taille)
• qwen3-4b-instruct-2507.Q4_K_M.gguf (Plus léger, pour ressources limitées)

🎓 Formation

Modèle basé sur Qwen3-4B-Instruct-2507 et fine-tuné sur un dataset de questions philosophiques utilisant la méthode socratique. L'entraînement s'est fait 2x plus rapidement grâce à Unsloth.

📚 Dataset

Entraîné sur le dataset Philosophie-questions-Socrate créé spécifiquement pour ce projet.

---