Points clés
Qwen2.5-7B est un LLM open source de taille moyenne avec 7,6 milliards de paramètres, un support de contexte de 128K et des performances générales robustes.
Qwen2.5-7B peut être déployé localement avec des GPU (par exemple, RTX 4090), mais les formats haute précision comme FP32 nécessitent des configurations matérielles coûteuses.
Pour une accessibilité plus large, l’accès via API via Novita AI offre une alternative évolutive et économique, entièrement compatible avec le SDK d’OpenAI.
Parrainez vos amis sur Novita AI et vous gagnerez tous les deux 10 $ de crédits API LLM, jusqu’à 500 $ de récompenses totales. Pour soutenir la communauté des développeurs, Qwen2.5-7B est actuellement disponible gratuitement sur Novita AI.
Qwen2.5-7B est un LLM open source polyvalent conçu pour des tâches générales, alliant puissance et efficacité. Avec le support de plus de 29 langues et une longueur de contexte massive de 128K, il permet un raisonnement sur de longs textes et une large couverture d’applications.
Qu’est-ce que Qwen 2.5 7B ?
Qwen 2.5 7B est un modèle de langage open source puissant de taille moyenne avec 7,6 milliards de paramètres, prenant en charge un contexte de 128K et optimisé pour les tâches générales.
Aperçu du modèle
- Taille du modèle : 7,61 milliards de paramètres
- Open Source : Oui
- Architecture : Transformers avec RoPE, SwiGLU, RMSNorm et biais Attention QKV
- Longueur de contexte : 128 tokens
Langues et multimodal
- Langues supportées : Prend en charge plus de 29 langues multilingues
- Capacité multimodale : Texte vers texte uniquement
Détails d’entraînement
- Volume de données d’entraînement : Entraîné sur un ensemble de données comprenant plus de 18 billions de tokens
Benchmark
Comparaison avec d’autres modèles Qwen 2.5
La série Qwen 2.5 propose une famille évolutive de modèles allant de 0,5B à 72B paramètres, incluant des variantes générales, de codage et mathématiques, conçues pour répondre à des besoins divers allant du déploiement léger aux applications d’IA haute performance.
Source : Qwen
-
Large gamme de tailles de modèles pour différents cas d’utilisation
La série Qwen 2.5 s’étend de 0,5B à 72B paramètres, y compris les variantes généralistes, Coder et Math, offrant ainsi une flexibilité pour diverses tâches et budgets de calcul. -
Les modèles plus grands bénéficient de fenêtres de contexte longues
La plupart des modèles prennent en charge des longueurs de contexte de 128K ou 32K, permettant un raisonnement sur de longs textes et des conversations à plusieurs tours. Seuls les modèles Math utilisent des contextes plus courts de 4K, optimisés pour les calculs denses. -
Tie Embedding utilisé de manière sélective
Le tie embedding est activé pour les modèles plus petits et spécialisés (par exemple, les variantes 1,5B), probablement pour réduire le nombre de paramètres, tandis que les modèles plus grands le désactivent pour améliorer la puissance de représentation. -
L’architecture évolue de manière prévisible avec la taille du modèle
- Couches : de 24 à 80
- Têtes d’attention : de 14/2 à 64/8 (split Q/KV)
Cela reflète une stratégie de mise à l’échelle structurée avec une profondeur et une largeur croissantes.
-
Les modèles spécialisés Coder et Math ont des longueurs de génération plus courtes
Ces modèles utilisent une longueur de génération de 2K et sont optimisés pour des tâches spécifiques comme la génération de code ou le raisonnement mathématique, privilégiant la précision à l’étendue du contexte.
Comment accéder à Qwen 2.5 7B localement
Recommandations GPU
| Quantification | Taille du modèle | GPU recommandé | Besoins en VRAM | Coût estimé du GPU (USD) |
|---|---|---|---|---|
| FP16 | ~16,1 Go | 1× RTX 4090 (24 Go) | ≥24 Go | ~1 600–1 800 $ |
| FP32 | ~32,2 Go | 2× RTX 4090 (24 Go chacun) | ≥48 Go | ~3 200–3 600 $ |
| 4-bit (Q4) | ~4,02 Go | RTX 3060 (12 Go) | ≥8 Go | ~300–350 $ |
Démarrage rapide
from transformers import AutoModelForCausalLM, AutoTokenizer
device = "cuda" # the device to load the model onto
model = AutoModelForCausalLM.from_pretrained(
"Qwen/Qwen2.5-7B-Instruct",
torch_dtype="auto",
device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-7B-Instruct")
prompt = "Give me a short introduction to large language model."
messages = [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": prompt}
]
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True
)
model_inputs = tokenizer([text], return_tensors="pt").to(device)
generated_ids = model.generate(
model_inputs.input_ids,
max_new_tokens=512
)
generated_ids = [
output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
Bien que l’exécution locale de Qwen2.5-7B offre un contrôle total et des temps de réponse plus rapides, le coût initial d’achat de GPU haut de gamme—en particulier pour un déploiement en pleine précision (FP32)—peut être considérablement plus élevé que l’utilisation d’une API à la carte. Pour les développeurs ou les équipes disposant de budgets limités, l’accès via API s’avère souvent une solution beaucoup plus économique et évolutive.
Comment accéder à Qwen 2.5 7B via API ?
Novita AI est une plateforme cloud d’IA qui offre aux développeurs un moyen simple de déployer des modèles d’IA via notre API simple, tout en fournissant un cloud GPU abordable et fiable pour construire et faire évoluer leurs modèles.
Vous pouvez commencer votre essai gratuit pour explorer les capacités du modèle sélectionné. Après l’installation, importez les bibliothèques nécessaires dans votre environnement de développement. Initialisez l’API avec votre clé API pour commencer à interagir avec Novita AI LLM. Voici un exemple d’utilisation de l’API de complétion de chat pour les utilisateurs Python.
Essayez la démo de Qwen 2.5 7B maintenant !
Intégration API directe
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
api_key="<YOUR Novita AI API Key>",
)
model = "qwen/qwen2.5-7B-Instruct"
stream = True # or False
max_tokens = 2048
system_content = """Be a helpful assistant"""
temperature = 1
top_p = 1
min_p = 0
top_k = 50
presence_penalty = 0
frequency_penalty = 0
repetition_penalty = 1
response_format = { "type": "text" }
chat_completion_res = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": system_content,
},
{
"role": "user",
"content": "Hi there!",
}
],
stream=stream,
max_tokens=max_tokens,
temperature=temperature,
top_p=top_p,
presence_penalty=presence_penalty,
frequency_penalty=frequency_penalty,
response_format=response_format,
extra_body={
"top_k": top_k,
"repetition_penalty": repetition_penalty,
"min_p": min_p
}
)
if stream:
for chunk in chat_completion_res:
print(chunk.choices[0].delta.content or "", end="")
else:
print(chat_completion_res.choices[0].message.content)
Flux de travail multi-agents avec le SDK OpenAI Agents
Construisez des systèmes multi-agents avancés en intégrant Novita AI avec le SDK OpenAI Agents :
- Prêt à l’emploi : Utilisez les LLM de Novita AI dans n’importe quel flux de travail OpenAI Agents.
- Prend en charge les transferts, le routage et l’utilisation d’outils : Concevez des agents capables de déléguer, trier ou exécuter des fonctions, le tout alimenté par les modèles de Novita AI.
- Intégration Python : Pointez simplement le SDK vers le point de terminaison de Novita (
https://api.novita.ai/v3/openai) et utilisez votre clé API.
Sur des plateformes tierces
- Hugging Face : Utilisez Qwen 3 dans Spaces, pipelines ou avec la bibliothèque Transformers via les points de terminaison Novita AI.
- Frameworks d’agents et d’orchestration : Connectez facilement Novita AI aux plateformes partenaires comme Continue, AnythingLLM, LangChain, Dify et Langflow grâce à des connecteurs officiels et des guides d’intégration étape par étape.
- API compatible OpenAI : Profitez d’une migration et d’une intégration sans effort avec des outils tels que Cline et Cursor, conçus pour la norme API OpenAI.
Que vous exécutiez Qwen2.5-7B localement ou via API, les développeurs ont accès à un ensemble d’outils puissants. Cependant, les coûts de déploiement local pour les GPU comme le RTX 4090 peuvent être prohibitifs, ce qui fait de l’intégration API de Novita AI un choix plus intelligent et plus évolutif pour la plupart des équipes.
Questions fréquemment posées
Comment exécuter Qwen 2.5 7B localement ?
Utilisez un GPU haut de gamme comme un RTX 4090. Le FP16 nécessite environ 24 Go de VRAM, tandis que le FP32 nécessite environ 48 Go. Vous devrez également installer la bibliothèque Transformers et charger le modèle avec AutoModelForCausalLM.
Comment l’accès via API se compare-t-il à l’exécution locale du modèle ?
L’accès via API élimine les coûts initiaux du GPU et offre une évolutivité élastique. Le déploiement local offre un contrôle mais est beaucoup plus coûteux pour les configurations en pleine précision.
Comment accéder à Qwen 2.5 7B via API ?
Novita AI fournit une API compatible OpenAI prête à l’emploi.
Novita AI est la plateforme cloud tout-en-un qui alimente vos ambitions en IA. API intégrées, sans serveur, instances GPU — les outils économiques dont vous avez besoin. Éliminez l’infrastructure, commencez gratuitement et faites de votre vision IA une réalité.
