YODI models
YODI offers several models optimized for different use cases, each with its own characteristics and capabilities.
Models overview​
| Modèle | Type | Capacités | Limite contexte | Coût |
|---|---|---|---|---|
yodi-1 | Chat/Completion | Conversation, génération | 8,192 tokens | Standard |
yodi-1-32k | Chat/Completion | Contexte étendu | 32,768 tokens | Premium |
yodi-embed | Embeddings | Recherche sémantique | 8,192 tokens | Économique |
yodi-code | Code | Programmation, debug | 8,192 tokens | Standard |
yodi-instruct | Instructions | Tâches spécifiques | 4,096 tokens | Économique |
YODI-1​
Caractéristiques​
- Type : Modèle de conversation généraliste
- Contexte : 8,192 tokens
- Langues : Multilingue (français, anglais, espagnol, allemand, etc.)
- Spécialités : Conversation naturelle, rédaction, analyse
Cas d'usage optimaux​
# Conversation générale
response = client.chat.completions.create(
model="yodi-1",
messages=[
{"role": "system", "content": "Tu es un assistant IA serviable."},
{"role": "user", "content": "Explique-moi la photosynthèse"}
],
temperature=0.7
)
# Rédaction créative
response = client.completions.create(
model="yodi-1",
prompt="Écris une histoire courte sur un robot qui découvre l'art",
max_tokens=500,
temperature=1.2
)
Paramètres recommandés​
| Cas d'usage | Temperature | Top_p | Max_tokens |
|---|---|---|---|
| Conversation | 0.7 | 0.9 | 150-500 |
| Rédaction créative | 1.0-1.5 | 0.9 | 300-1000 |
| Analyse factuelle | 0.1-0.3 | 0.8 | 200-800 |
| Résumé | 0.3 | 0.8 | 100-300 |
YODI-1-32K​
Caractéristiques​
- Type : Version étendue de YODI-1
- Contexte : 32,768 tokens (~25,000 mots)
- Avantages : Traitement de documents longs, conversations étendues
- Coût : Plus élevé que YODI-1
Cas d'usage spécialisés​
# Analyse de document long
def analyze_long_document(document_text):
return client.chat.completions.create(
model="yodi-1-32k",
messages=[
{"role": "system", "content": "Analyse ce document et fournis un résumé détaillé avec les points clés."},
{"role": "user", "content": document_text}
],
max_tokens=1500,
temperature=0.3
)
# Conversation avec historique étendu
def extended_conversation(long_conversation_history):
return client.chat.completions.create(
model="yodi-1-32k",
messages=long_conversation_history,
max_tokens=300
)
Quand utiliser YODI-1-32K​
- Documents > 6,000 mots
- Conversations > 50 échanges
- Analyse comparative de textes multiples
- Traitement de codes sources complets
YODI-Embed​
Caractéristiques​
- Type : Modèle d'embeddings
- Dimensions : 1,536
- Spécialité : Représentations vectorielles sémantiques
- Performance : Optimisé pour la recherche et la similarité
Métriques de performance​
| Benchmark | Score | Rang |
|---|---|---|
| MTEB French | 82.3% | Top 5 |
| Semantic Similarity | 89.1% | Top 3 |
| Information Retrieval | 85.7% | Top 5 |
| Classification | 87.2% | Top 5 |
Utilisation optimale​
# Recherche sémantique
def semantic_search_setup(documents):
embeddings = []
for doc in documents:
response = client.embeddings.create(
model="yodi-embed",
input=doc
)
embeddings.append(response.data[0].embedding)
return embeddings
# Classification automatique
def classify_text(text, categories_embeddings):
text_response = client.embeddings.create(
model="yodi-embed",
input=text
)
text_embedding = text_response.data[0].embedding
# Calculer similarités avec chaque catégorie
similarities = []
for category, cat_embedding in categories_embeddings.items():
similarity = cosine_similarity([text_embedding], [cat_embedding])[0][0]
similarities.append((category, similarity))
return max(similarities, key=lambda x: x[1])
YODI-Code​
Caractéristiques​
- Type : Modèle spécialisé pour le code
- Langages : Python, JavaScript, Java, C++, Go, Rust, etc.
- Capacités : Génération, débogage, explication, optimisation
Fonctionnalités avancées​
# Génération de code
response = client.chat.completions.create(
model="yodi-code",
messages=[
{"role": "system", "content": "Tu es un expert en Python. Écris du code propre et bien documenté."},
{"role": "user", "content": "Crée une fonction pour calculer la suite de Fibonacci avec mémoïzation"}
],
temperature=0.2
)
# Débogage et explication
response = client.chat.completions.create(
model="yodi-code",
messages=[
{"role": "system", "content": "Analyse ce code et explique les erreurs potentielles."},
{"role": "user", "content": """
def calculate_average(numbers):
total = 0
for num in numbers:
total += num
return total / len(numbers)
result = calculate_average([])
print(result)
"""}
],
temperature=0.1
)
Bonnes pratiques avec YODI-Code​
# Template pour génération de code sécurisée
def generate_secure_code(description, language="python"):
system_prompt = f"""Tu es un expert en {language}.
Règles importantes :
1. Écris du code sécurisé et robuste
2. Inclus la gestion d'erreurs
3. Ajoute des commentaires explicatifs
4. Respecte les conventions du langage
5. Évite les vulnérabilités communes
"""
response = client.chat.completions.create(
model="yodi-code",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": description}
],
temperature=0.2,
max_tokens=1000
)
return response.choices[0].message.content
# Révision de code automatisée
def code_review(code, language="python"):
review_prompt = f"""Fais une révision complète de ce code {language} :
{code}
Analyse :
1. Qualité du code
2. Performance
3. Sécurité
4. Maintenabilité
5. Suggestions d'amélioration
"""
response = client.chat.completions.create(
model="yodi-code",
messages=[{"role": "user", "content": review_prompt}],
temperature=0.1
)
return response.choices[0].message.content
YODI-Instruct​
Caractéristiques​
- Type : Modèle optimisé pour suivre des instructions
- Contexte : 4,096 tokens
- Spécialité : Tâches précises, formatage, extraction
Cas d'usage spécialisés​
# Extraction d'informations structurées
def extract_information(text, schema):
prompt = f"""Extrait les informations suivantes du texte :
Schéma requis : {schema}
Texte : {text}
Réponds uniquement au format JSON valide."""
response = client.chat.completions.create(
model="yodi-instruct",
messages=[{"role": "user", "content": prompt}],
temperature=0.1,
max_tokens=500
)
return response.choices[0].message.content
# Formatage de données
def format_data(data, output_format):
prompt = f"""Convertis ces données au format {output_format} :
{data}
Respecte strictement le format demandé."""
response = client.chat.completions.create(
model="yodi-instruct",
messages=[{"role": "user", "content": prompt}],
temperature=0.0
)
return response.choices[0].message.content
Choix du modèle optimal​
Arbre de décision​
def choose_optimal_model(task_type, context_length, creativity_needed):
if task_type == "embeddings":
return "yodi-embed"
elif task_type == "code":
return "yodi-code"
elif task_type == "structured_task":
return "yodi-instruct"
elif context_length > 8000:
return "yodi-1-32k"
else:
return "yodi-1"
# Exemples d'utilisation
model = choose_optimal_model("conversation", 2000, True) # -> "yodi-1"
model = choose_optimal_model("code", 1000, False) # -> "yodi-code"
model = choose_optimal_model("conversation", 15000, True) # -> "yodi-1-32k"
Matrice de coûts​
| Modèle | Coût relatif | Performance | Cas d'usage optimal |
|---|---|---|---|
| yodi-instruct | 1x | Rapide | Tâches simples |
| yodi-embed | 0.5x | Spécialisé | Recherche/similarité |
| yodi-1 | 2x | Élevée | Usage général |
| yodi-code | 2x | Spécialisée | Programmation |
| yodi-1-32k | 4x | Très élevée | Contextes longs |
Optimisation des performances​
Cache par modèle​
from functools import lru_cache
@lru_cache(maxsize=1000)
def cached_model_call(model, prompt_hash, **kwargs):
return client.chat.completions.create(
model=model,
**kwargs
)
def smart_model_call(messages, task_type="general", **kwargs):
model = choose_optimal_model(task_type, len(str(messages)), kwargs.get('temperature', 0.7) > 1.0)
prompt_hash = hash(str(messages) + str(kwargs))
return cached_model_call(model, prompt_hash, messages=messages, **kwargs)
Fallback automatique​
def robust_model_call(messages, preferred_model="yodi-1", **kwargs):
fallback_models = {
"yodi-1-32k": "yodi-1",
"yodi-1": "yodi-instruct",
"yodi-code": "yodi-1",
"yodi-instruct": "yodi-1"
}
models_to_try = [preferred_model]
if preferred_model in fallback_models:
models_to_try.append(fallback_models[preferred_model])
for model in models_to_try:
try:
response = client.chat.completions.create(
model=model,
messages=messages,
**kwargs
)
return response, model
except Exception as e:
if "context_length_exceeded" in str(e) and model != "yodi-1-32k":
# Essayer le modèle avec plus de contexte
return robust_model_call(messages, "yodi-1-32k", **kwargs)
continue
raise Exception("Tous les modèles ont échoué")
Monitoring et métriques​
Suivi des performances par modèle​
import time
from collections import defaultdict
class ModelMonitor:
def __init__(self):
self.stats = defaultdict(lambda: {
'calls': 0,
'total_time': 0,
'total_tokens': 0,
'errors': 0
})
def track_call(self, model, start_time, end_time, tokens_used=0, error=False):
stats = self.stats[model]
stats['calls'] += 1
stats['total_time'] += (end_time - start_time)
stats['total_tokens'] += tokens_used
if error:
stats['errors'] += 1
def get_report(self):
report = {}
for model, stats in self.stats.items():
avg_time = stats['total_time'] / max(stats['calls'], 1)
error_rate = stats['errors'] / max(stats['calls'], 1)
report[model] = {
'calls': stats['calls'],
'avg_response_time': avg_time,
'total_tokens': stats['total_tokens'],
'error_rate': error_rate
}
return report
monitor = ModelMonitor()
def monitored_model_call(model, messages, **kwargs):
start_time = time.time()
try:
response = client.chat.completions.create(
model=model,
messages=messages,
**kwargs
)
end_time = time.time()
tokens = response.usage.total_tokens if response.usage else 0
monitor.track_call(model, start_time, end_time, tokens)
return response
except Exception as e:
end_time = time.time()
monitor.track_call(model, start_time, end_time, error=True)
raise