Qwen3-Next : Un guide avec un projet de démonstration

L'équipe Qwen a récemment lancé le modèle Qwen3-Next-80B-A3B , qui combine un raisonnement avancé, une gestion du contexte ultra-longue et une vitesse d'inférence exceptionnelle grâce à une architecture hybride Mixture-of-Experts (MoE).

Dans ce guide, je me concentrerai sur les performances du Qwen3-Next-80B-A3B dans des tâches pratiques et réelles, par rapport aux modèles Qwen précédents tels que le Qwen3-30B-A3B. Au lieu de recourir à des benchmarks abstraits, nous effectuerons des tests pratiques comparatifs, incluant des exercices de raisonnement, du code et des invites de document ultra-longues, afin que vous puissiez observer les compromis en termes de vitesse, de qualité de sortie et d'utilisation de la mémoire GPU.

Étape par étape, je vais vous expliquer comment :

• Accédez et interagissez avec Qwen3-Next-80B-A3B et Qwen3-30B-A3B via l'API OpenRouter, sans aucune configuration requise.
• Développez une application Streamlit pour une comparaison instantanée et côte à côte des réponses des modèles, de la latence et de l'utilisation des ressources.
• Effectuez des expériences de récupération de contexte ultra-longues (plus de 100 000 jetons) afin d'évaluer les limites réelles des modèles.
• Analysez les indicateurs de performance réels tels que la latence, les jetons/seconde et l'utilisation de la mémoire VRAM.

À la fin, votre application ressemblera à ceci :

Qu'est-ce que Qwen3-Next ?

Qwen3-Next est un modèle MoE (Mixture-of-Experts) de 80 milliards de paramètres. modèle de mélange d'experts (MoE). En pratique, il n'active que 3B paramètres par jeton, ce qui le rend jusqu'à dix fois moins coûteux à entraîner et dix fois plus rapide à exécuter que les anciens modèles denses (tels que Qwen3-32B), tout en égalant ou surpassant leur qualité.

Parmi les avancées majeures de ce modèle, on peut citer :

• Architecture hybride: Qwen3-Next utilise un mélange 75:25 de Gated DeltaNet (pour une attention linéaire rapide) et de Gated Attention (pour une mémorisation approfondie), combinant ainsi les atouts des deux méthodes.
• MoE ultra-clairsemée: Il emploie 512 experts, mais n'en active que 10+1 par inférence, ce qui réduit le calcul de plus de 90 % par rapport aux LLM denses.
• de prédiction multi-jetons: Ce modèle prend en charge le décodage spéculatif. décodage spéculatif, ce qui permet d'importants gains de vitesse, en particulier dans le streaming ou le chat.
• s de contexte extrêmement longues: Il traite jusqu'à 256 Ko de jetons en mode natif (plus d'un million avec la mise à l'échelle YaRN) avec une perte de performance minimale, et est idéal pour les livres volumineux, les bases de code, etc.

Source : Qwen

Le modèle Qwen 3 Next est disponible en deux variantes :

• Qwen3-Next-80B-A3B-Instructions : Ce modèle est conçu pour les discussions générales, le codage et les questions-réponses ouvertes.
• Qwen3-Next-80B-A3B-Réflexion : Ce modèle peut être utilisé pour le raisonnement avancé, la chaîne de pensée et les flux de travail de recherche.

Démonstration : Questions-réponses et raisonnement avec Qwen3-Next et l'API OpenRouter

Dans cette section, je vais vous montrer comment utiliser le modèle Qwen3-Next via l'OpenRouter. API OpenRouter pour créer un assistant interactif de questions-réponses et de raisonnement.

Voici comment cela fonctionne :

• Veuillez saisir une question dans la zone de texte ou glisser-déposer un document PDF volumineux.
• Veuillez sélectionner le taille maximale des jetons et le nom du modèle dans le menu déroulant.
• Effectuez instantanément une requête sur deux modèles côte à côte pour une comparaison directe des résultats.
• Consultez les mesures détaillées pour chaque exécution, notamment le temps de réponse (latence), les jetons par seconde et la longueur de sortie, afin de comprendre à la fois les performances et l'efficacité dans des scénarios pratiques.

Étape 1 : Conditions préalables

Avant de lancer cette démonstration, veuillez vous assurer que toutes les conditions préalables sont remplies.

Étape 1.1 : Importations 

Tout d'abord, veuillez vous assurer que les importations suivantes sont installées :

pip install streamlit requests pypdf

Cette commande installe toutes les dépendances essentielles nécessaires à la création de l'application, à savoir Streamlit pour l'interface utilisateur, requests pour les appels API et pypdf pour l'extraction de documents PDF.

Étape 1.2 : Configuration de la clé API OpenRouter 

Le modèle Qwen3-Next est également accessible via l'API officielle Qwen (AlibabaCloud), HuggingFaceet en version quantifiée via Ollama. Pour ce tutoriel, j'ai utilisé OpenRouter, qui permet d'accéder à plusieurs modèles à l'aide d'une seule clé API. Voici comment configurer votre clé API pour le modèle Qwen3-next-80b-a3b-instruct :

• Veuillez créer un compte sur https://openrouter.ai/
• Veuillez vous rendre dans l'onglet Modèles et rechercher les modèles « Qwen3-next-80b-a3b-instruct » et « Qwen3-30B-A3B ». Vous pouvez choisir entre les variantes Thinking et Instruct en fonction de votre application. Dans ce tutoriel, je compare les deux variantes du modèle Instruct.

• Veuillez faire défiler vers le bas et cliquer sur « Créer une clé API » dans la section «». Veuillez saisir le nom de la clé et la limite de crédit (facultatif), puis cliquer sur Créer l'. Veuillez conserver cette clé API pour une utilisation ultérieure. 

• Ensuite, veuillez vous rendre dans l'onglet «Crédits » et ajouter les informations relatives à votre carte ou à votre compte bancaire. Vous pouvez également effectuer votre paiement via Amazon Pay ou en utilisant des cryptomonnaies. Pour cette démonstration, j'ai ajouté environ 8 dollars, ce qui était suffisant.

Veuillez définir votre clé API en tant que variable d'environnement avant de lancer l'application :

export OPENROUTER_API_KEY=your_api_key

Étape 2 : Configuration du modèle

Nous commençons par configurer les modèles que nous souhaitons comparer. Chaque modèle est défini par un identifiant (utilisé pour les appels API), le nombre total de paramètres et le nombre de paramètres actifs.

import streamlit as st
import requests
import time
import PyPDF2
MODEL_CONFIG = {
    "Qwen3-Next-80B-A3B": {
        "id": "qwen/qwen3-next-80b-a3b-instruct",
        "params_billion": 80,
        "active_params_billion": 3
    },
    "Qwen3-30B-A3B": {
        "id": "qwen/qwen3-30b-a3b-instruct-2507",
        "params_billion": 30,
        "active_params_billion": 3
    },
    "Qwen3-30B-A3B": {
        "id": "qwen/qwen3-next-80b-a3b-thinking",
        "params_billion": 30,
        "active_params_billion": 3
    },
}

Nous commençons par importer les bibliothèques nécessaires à la création de l'application web Streamlit, notamment les bibliothèques telles que streamlit pour l'interface utilisateur, requests pour les appels API, time pour la synchronisation et PyPDF2 pour l'extraction de texte PDF.

Ensuite, nous définissons le dictionnaire MODEL_CONFIG qui recense les modèles disponibles à des fins de comparaison, y compris leurs identifiants uniques (pour les appels API) et le nombre de paramètres, ce qui facilite l'extension de différents modèles Qwen3 dans l'ensemble de l'application.

Étape 3 : Fonctions d'assistance

Ensuite, nous définissons plusieurs fonctions d'aide pour le backend. Il s'agit notamment de fonctions permettant d'estimer les besoins en mémoire, d'effectuer des appels API en temps réel vers OpenRouter et d'extraire du texte à partir de fichiers PDF téléchargés.

def estimate_vram(params_billion, fp16=True, active_params_billion=None):
    if active_params_billion and active_params_billion != params_billion:
        total_params = params_billion * 1e9
        active_params = active_params_billion * 1e9
        size_bytes = 2 if fp16 else 4
        storage_vram = total_params * size_bytes / 1e9
        moe_overhead = active_params * 0.5 / 1e9  
        system_overhead = storage_vram * 0.2  
        total_vram = storage_vram + moe_overhead + system_overhead
    else:
        size_bytes = 2 if fp16 else 4
        num_params = params_billion * 1e9
        base_vram = num_params * size_bytes / 1e9
        total_vram = base_vram * 1.3 
    return round(total_vram, 1)
def query_openrouter(model_id, prompt, max_tokens=2048):
    api_key = "sk-or-v1-xxxxxxxxxxxxxxxxxxxxx" # Add your API Key here
    url = "https://openrouter.ai/api/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    data = {
        "model": model_id,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": max_tokens
    }
    try:
        start = time.time()
        response = requests.post(url, headers=headers, json=data, timeout=180)
        elapsed = time.time() - start
        response.raise_for_status()
        j = response.json()
        output = j["choices"][0]["message"]["content"].strip()
        usage = j.get("usage", {})
        prompt_tokens = usage.get("prompt_tokens", 0)
        completion_tokens = usage.get("completion_tokens", 0)
        tokens_per_sec = (completion_tokens or 0) / elapsed if elapsed > 0 else 0
        return {
            "output": output,
            "latency": elapsed,
            "output_tokens": completion_tokens,
            "tokens_per_sec": tokens_per_sec,
            "prompt_tokens": prompt_tokens
        }
    except Exception as e:
        return {"error": str(e)}
def extract_pdf_text(uploaded_pdf):
    text = ""
    try:
        reader = PyPDF2.PdfReader(uploaded_pdf)
        for page in reader.pages:
            text += page.extract_text() or ""
        return text[:120000]  
    except Exception as e:
        return f"[PDF extract error: {str(e)}]"

Comprenons comment chaque fonction s'intègre dans le pipeline :

• estimate_vram() fonction : Cette fonction estime la mémoire VRAM du GPU nécessaire pour exécuter un modèle, en tenant compte du fait qu'il s'agit d'un modèle dense ou MoE (Mixture-of-Experts). Pour les modèles MoE, il prend en compte à la fois les paramètres totaux et actifs et ajoute une surcharge pour le routage et l'utilisation du système.
• query_openrouter() fonction : Cette fonction est chargée d'envoyer des invites à un modèle LLM sélectionné hébergé sur OpenRouter et de récupérer la réponse. Il mesure la latence totale (temps d'appel API de bout en bout), extrait des métriques utiles telles que le nombre de jetons traités et calcule le taux de génération de jetons par seconde. 

Veuillez noter que la latence indiquée ici inclut tous les délais liés au réseau, à la mise en file d'attente et au serveur, et non pas uniquement la vitesse d'inférence du modèle. En tant que tel, il reflète la réactivité réelle de bout en bout, qui peut varier en fonction de la charge de l'API et des conditions Internet.

• extract_pdf_text() fonction : Cette fonctionnalité permet aux utilisateurs de télécharger et d'analyser des fichiers PDF comme contexte d'entrée pour les modèles. Il analyse le document PDF à l'aide de PyPDF2 et extrait le texte brut, jusqu'à une limite sécurisée pour les documents très longs. Si l'analyse échoue, la fonction renvoie un message d'erreur.

Ces fonctions d'assistance garantissent une utilisation efficace de la mémoire, une inférence fiable basée sur l'API et une extraction fluide du contexte, offrant ainsi une expérience utilisateur optimale.

Étape 4 : Application Streamlit

Tous les composants principaux étant prêts, nous pouvons maintenant créer notre application Streamlit.

Étape 4.1 : CSS personnalisé

La première étape dans la création du flux de travail destiné aux utilisateurs consiste en la conception visuelle et la mise en page. Ici, nous configurons la page Streamlit et intégrons un CSS personnalisé pour obtenir un aspect structuré.

st.set_page_config(page_title="Qwen3-Next QA & Reasoning", layout="wide", page_icon=" ")
st.markdown("""
<style>
    .main-header {
        text-align: center;
        
        
    }
    .metric-card {
        background-
        
        border-radius: 0.5rem;
        border-left: 4px solid #1f77b4;
        
    }
    .output-box {
        background-
        border: 2px solid #e1e5e9;
        border-radius: 0.5rem;
        
        
        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    }
    .model-header {
        background: linear-gradient(90deg, #1f77b4, #ff7f0e);
        color: white;
        
        border-radius: 0.5rem;
        
        text-align: center;
        font-weight: bold;
    }
</style>
""", unsafe_allow_html=True)
st.markdown('<h1 class="main-header"> QA and Reasoning With Qwen3-Next</h1>', unsafe_allow_html=True)
st.markdown("""
<div style="text-align: center; ">
    <p style="">
        Compare two Qwen3 models side-by-side with real-time performance metrics
    </p>
</div>
""", unsafe_allow_html=True)

Nous utilisons à la fois les options de configuration de Streamlit et les paramètres de style CSS personnalisés. L'appel st.set_page_config définit le titre de la page et une mise en page large pour une sortie côte à côte. Le CSS personnalisé est intégré via st.markdown afin de styliser les principaux éléments de l'interface utilisateur.

.main-header e et met en couleur le titre, .metric-card et .output-box améliorent l'affichage des mesures et des résultats, et .model-header sépare visuellement les réponses du modèle à l'aide d'un dégradé. Le bloc final d'st.markdown s affiche un titre et une brève description de l'application.

Étape 4.2 : Section d'entrée

Nous avons conçu la section de saisie en proposant aux utilisateurs deux options intuitives : télécharger un long fichier PDF comme contexte ou saisir directement une question personnalisée.

st.markdown("### Input")
with st.container():
    col_upload, col_text = st.columns([2, 3])
    with col_upload:
        uploaded_pdf = st.file_uploader(
            "Upload PDF for context", 
            type=["pdf"],
            help="Upload a PDF document to provide context for your question"
        )
    with col_text:
        user_question = st.text_area(
            "Ask a question:", 
            height=100, 
            max_chars=12000,
            placeholder="Enter your question here...",
            help="Ask any question or provide a topic to analyze"
        )

Cette section d'entrée affiche deux colonnes côte à côte : la première colonne fournit un outil de téléchargement de fichiers PDF permettant aux utilisateurs d'ajouter des documents contextuels, tandis que la seconde colonne offre une zone de texte pour saisir des questions ou des sujets. Cette interface permet aux utilisateurs de télécharger un fichier PDF, de saisir une question ou d'utiliser les deux à la fois comme données d'entrée pour la comparaison des modèles en aval.

Étape 4.3 : Sélection du modèle

La section de sélection des modèles permet aux utilisateurs de contrôler entièrement les modèles Qwen à comparer, ainsi que la longueur des réponses des modèles. Une fois le contexte du document défini, les utilisateurs peuvent facilement sélectionner deux modèles dans une liste déroulante, ainsi que la longueur maximale souhaitée pour la réponse (en jetons), ce qui facilite l'expérimentation de sorties courtes et longues.

context = ""
if uploaded_pdf:
    with st.spinner(" Extracting PDF text..."):
        context = extract_pdf_text(uploaded_pdf)
    st.success(f" PDF loaded: {len(context)//1000}K characters extracted.")
st.markdown("### Model Selection")
model_names = list(MODEL_CONFIG.keys())
col1, col2, col3 = st.columns([2, 2, 1])
with col1:
    model1 = st.selectbox(
        "Model A", 
        model_names, 
        index=0,
        help="Select the first model to compare"
    )
with col2:
    model2 = st.selectbox(
        "Model B", 
        model_names, 
        index=1 if len(model_names) > 1 else 0,
        help="Select the second model to compare"
    )
with col3:
    max_tokens = st.selectbox(
        "Max Tokens",
        [512, 1024, 2048, 4096],
        index=2,  
        help="Maximum length of response (higher = longer responses). Use 2048+ for reasoning questions."
    )

Le code ci-dessus extrait d'abord le texte d'un fichier PDF téléchargé à l'aide d'une fonction d'aide. Il affiche ensuite trois menus déroulants : deux pour sélectionner les modèles Qwen (ou tout autre modèle selon l'application) à comparer, et un pour spécifier la limite maximale de tokens pour les réponses.

Remarque : La limite de jetons contrôle la longueur maximale de sortie. Pour les tâches de raisonnement complexes ou en plusieurs étapes, définir une limite de jetons plus élevée garantit que le modèle peut générer une réponse complète.

Étape 4.4 : Soumission

Cette étape met en œuvre la logique principale de comparaison des modèles. Lorsque l'utilisateur clique sur « Soumettre et comparer les modèles », l'application valide les données saisies, génère une invite contextuelle et lance des requêtes parallèles aux modèles sélectionnés.

st.markdown("---")
col_btn1, col_btn2, col_btn3 = st.columns([1, 2, 1])
with col_btn2:
    if st.button("Submit & Compare Models", type="primary", use_container_width=True):
        if not user_question and not uploaded_pdf:
            st.warning(" Please enter a question or upload a PDF.")
        else:
            if context:
                base_prompt = f"DOCUMENT:\n{context}\n\nQUESTION: {user_question or 'Summarize the above document.'}"
            else:
                base_prompt = user_question
            prompt = f"""Please provide a detailed and thorough response. Think step by step and explain your reasoning clearly.
{base_prompt}
Please provide a comprehensive answer with clear reasoning and examples where appropriate."""           
            st.markdown("### Results")
            col_left, col_right = st.columns(2)
            models_to_process = [(model1, col_left, "Model A"), (model2, col_right, "Model B")]          
            for model_key, col, model_label in models_to_process:
                with col:
                    st.markdown(f'<div class="model-header">{model_label}: {model_key}</div>', unsafe_allow_html=True)                   
                    progress_bar = st.progress(0)
                    status_text = st.empty()                    
                    try:
                        progress_bar.progress(25)
                        status_text.text("Initializing model...")
                        model_info = MODEL_CONFIG[model_key]
                        vram_estimate = estimate_vram(
                            model_info["params_billion"], 
                            active_params_billion=model_info["active_params_billion"]
                        )
                        progress_bar.progress(50)
                        status_text.text("Querying model...")
                        result = query_openrouter(model_info["id"], prompt, max_tokens=max_tokens)                        
                        progress_bar.progress(100)
                        status_text.text("Complete!")
                        if "error" in result:
                            st.error(f"Error: {result['error']}")
                        else:
                            st.markdown(f'''
                            <div class="metric-card">
                                <strong>Performance Metrics</strong><br>
                                <strong>Latency:</strong> {result['latency']:.2f}s<br>
                                <strong>Speed:</strong> {result['tokens_per_sec']:.2f} tokens/sec<br>
                                <strong>Output tokens:</strong> {result['output_tokens']}<br>
                                <strong>Prompt tokens:</strong> {result['prompt_tokens']}<br>
                                <strong>Est. VRAM:</strong> {vram_estimate} GB
                            </div>
                            ''', unsafe_allow_html=True)
                            st.markdown("** Response:**")
                            st.markdown(f'''
                            <div class="output-box">
                                {result["output"] if result["output"] else "<em>No output received</em>"}
                            </div>
                            ''', unsafe_allow_html=True)                
                    except Exception as e:
                        st.error(f" Unexpected error: {str(e)}")                    
                    finally:
                        progress_bar.empty()
                        status_text.empty()            
            st.markdown("---")            

Le gestionnaire de soumission organise le flux de travail de benchmarking de la manière suivante : 

• Lorsque l'utilisateur clique sur « Soumettre et comparer les modèles », l'application vérifie si une question ou un fichier PDF est fourni et avertit si aucun des deux n'est présent.
• Il génère ensuite une invite à partir du contexte du document et de la question de l'utilisateur, en ajoutant des instructions pour des réponses détaillées, étape par étape.
• La zone des résultats est divisée en deux colonnes afin de permettre une comparaison directe et côte à côte des résultats des modèles.
• Pour chaque modèle, il affiche une barre de progression, estime l'utilisation de la VRAM, interroge l'API OpenRouter et met à jour les messages d'état à mesure que le modèle traite la demande.
• Une fois terminée, l'application affiche la latence, les jetons par seconde, le nombre de jetons et l'utilisation de la VRAM sous forme de cartes représentant les indicateurs de performance.

Test de Qwen3-Next

Afin d'évaluer les performances réelles du modèle Qwen3-Next, j'ai réalisé plusieurs expériences.

Test 1 : Questions-réponses dans un contexte étendu

Afin d'évaluer les performances de Qwen3-Next dans un contexte à long terme, j'ai mené plusieurs expériences pratiques à l'aide de l' le livre électronique « War and Peace », l'un des romans les plus longs et les plus complexes jamais écrits.

Vous trouverez ci-dessous trois cas de test qui démontrent comment les modèles gèrent les contextes extrêmement longs, évitent les hallucinations et fournissent des résumés de haute qualité.

Suivi des personnages 

Tout d'abord, j'ai demandé aux deux modèles d'identifier tous les personnages principaux qui apparaissent à la fois dans le premier et le dernier chapitre du roman, et de décrire brièvement comment leur rôle évolue au fil de l'histoire.

s sur la commande: Veuillez énumérer tous les personnages principaux qui apparaissent à la fois dans le premier et le dernier chapitre du roman. Veuillez décrire brièvement comment leurs rôles évoluent au fil du temps.

Cette question nécessite que le modèle traite le texte intégral et suive avec précision les arcs narratifs. Bien que les deux modèles aient été très réactifs, la réponse de Qwen3 Next était plus claire et mieux adaptée à chaque chapitre du livre.

Test d'hallucination

Ensuite, j'ai souhaité déterminer si les modèles pouvaient distinguer le contenu authentique des informations erronées. J'ai fourni aux deux modèles une phrase qui n'apparaît pas dansGuerre et Paix d' , mais qui est célèbre dans un autre roman de Tolstoï.

Invite : Le roman contient-il la phrase « Toutes les familles heureuses se ressemblent ; chaque famille malheureuse est malheureuse à sa manière » ? Si tel est le cas, à quel endroit du texte cela apparaît-il ?

Cette phrase est en réalité tirée d'Anna Karénine, et non de Guerre et Paix. Un modèle idéal devrait répondre « Non », ce qui démontre une grande précision factuelle et un faible niveau d'hallucination. Il est remarquable de constater que Qwen3-Next a fourni la réponse correcte, tandis que le modèle Qwen3 30B a répondu par une phrase incorrecte.

Résumé

Enfin, j'ai évalué les capacités de synthèse en demandant aux deux modèles de résumer le roman en 300 mots.

Invite : Veuillez résumer le roman « Guerre et Paix » en 300 mots, en mettant l'accent sur le parcours personnel de Pierre Bezukhov.

Bien que l'évaluation sommaire soit en partie subjective, j'ai trouvé que les résultats de Qwen3-Next étaient plus structurés, cohérents et pertinents. Le résumé était non seulement concis, mais il rendait également compte avec clarté de l'évolution du personnage de Pierre.

Exemple 2 : Raisonnement et logique en plusieurs étapes

Afin de tester les capacités de raisonnement avancées des deux modèles, je leur ai soumis des énigmes logiques complexes en plusieurs étapes, des tâches qui requièrent non seulement de la mémoire, mais également une déduction progressive et une élimination minutieuse.

Puzzle logique sur la disposition des sièges

J'ai d'abord présenté aux modèles un casse-tête sur la disposition des sièges:

Invite : «Lors de la réception de mariage, cinq invités, Colin, Emily, Kate, Fred et Irene, ne savent pas où s'asseoir à table. Ils interrogent la mère de la mariée, qui répond : « Si je me souviens bien, Colin n'est pas à côté de Kate, et Emily n'est pas à côté de Fred ou de Kate. » Ni Kate ni Emily ne sont à côté d'Irene. Et Fred devrait s'asseoir à la gauche d'Irene. Lorsque vous les observez depuis le côté opposé de la table, êtes-vous en mesure de placer correctement les invités de gauche à droite ?

Veuillez expliquer votre raisonnement étape par étape.

Ce casse-tête nécessitait d'analyser plusieurs contraintes et de déduire le seul ordre possible pour l'attribution des places :

• Vérité terrain : Emily, Colin, Irène, Fred, Kate
• Sortie Qwen3-Next : Kate, Fred, Irène, Colin, Emily (presque correct, mais inversé)
• Sortie Qwen3-30B : Impossible de trouver une réponse valide

Bien qu'aucun des deux modèles n'ait obtenu la séquence exacte, Qwen3-Next s'en est approché de très près, inversant seulement l'ordre, tandis que le modèle 30B n'a pas réussi à trouver de solution. Cela démontre que Qwen3-Next est capable d'effectuer des déductions en plusieurs étapes, même si certains cas limites restent complexes.

Élimination déductive 

Ensuite, j'ai évalué les modèles à l'aide d'un casse-tête de déduction inspiré du casse-tête classique « Zebra puzzle ».

Invite : . Quatre personnes (Lisa, Mike, Nora et Omar) ont chacune acheté un fruit différent (pomme, banane, cerise, datte) et conduit une voiture différente (Ford, Honda, Kia, Mazda).

• Lisa n'a pas acheté la banane.
• Le conducteur de la Ford a acquis la cerise.
• Mike conduisait une Honda.
• Nora a acheté la pomme et ne conduisait pas une Mazda.
• Le conducteur de la Kia a accepté le rendez-vous.
• Omar ne conduisait pas une Ford.

Qui a acheté quels fruits et conduit quelle voiture ? Veuillez présenter votre travail.

Ce problème est intentionnellement insoluble avec les contraintes fournies, mais voici ce que les modèles ont renvoyé à la place :

• Sortie Qwen3-Next : Il a correctement identifié qu'aucune affectation valide n'existe.
• s de sortie du Qwen3-30B: Il s'est retrouvé dans une boucle logique et n'a pas réussi à conclure dans le nombre de jetons de sortie donné.

Cet exemple démontre la capacité de Qwen3-Next à raisonner de manière déductive et à reconnaître lorsqu'aucune solution n'est possible.

Conclusion

Ce tutoriel explique comment utiliser Qwen3-Next-80B-A3B pour des tâches de questions-réponses et de raisonnement, en le comparant à Qwen3-30B-A3B dans une application Streamlit côte à côte. Les résultats mettent en évidence les atouts de Qwen3-Next dans le traitement de documents extrêmement longs, la rapidité de l'inférence et le maintien de la qualité des résultats, même pour des problèmes de raisonnement complexes.