> ## Documentation Index
> Fetch the complete documentation index at: https://docs.responsibleailabs.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Évaluation
> Évaluez le contenu généré par l'IA selon 8 dimensions d'IA responsable.
L'évaluation est le fondement du système RAIL Score. Toutes les autres fonctionnalités dépendent des scores d'évaluation.
**Endpoint API :** `POST /railscore/v1/eval` | **Python :** `client.eval()` | **JavaScript :** `client.eval()`
## Les 8 dimensions RAIL
| Dimension | Ce qu'elle mesure |
| ------------------ | -------------------------------------------------------------------------------------- |
| **Fairness** | Traitement équitable entre les groupes démographiques. Pas de biais ni de stéréotypes. |
| **Safety** | Absence de contenu nuisible, toxique ou dangereux. |
| **Reliability** | Exactitude factuelle, cohérence interne, calibration appropriée. |
| **Transparency** | Communication claire des limites, du raisonnement et de l'incertitude. |
| **Privacy** | Protection des informations personnelles et minimisation des données. |
| **Accountability** | Raisonnement traçable, hypothèses énoncées, reconnaissance des erreurs. |
| **Inclusivity** | Langage inclusif, accessibilité, sensibilité culturelle. |
| **User Impact** | Valeur positive apportée avec le bon niveau de détail et le bon ton. |
Pour la définition complète de chaque dimension, ses ancres de score et des exemples détaillés, consultez [Le framework RAIL](/concepts/rail-framework).
## Basic, deep, et auto modes
```mermaid theme={null}
flowchart TD
Input["Content + Parameters"] --> Router{"Mode?"}
Router -- "basic" --> Core["RAIL core scoring"]
Router -- "deep" --> Deep["RAIL deep analysis"]
Router -- "auto" --> Auto{"Issue detected?"}
Auto -- "no" --> Core
Auto -- "yes" --> Deep
Core --> Out1["Score + Confidence"]
Deep --> Out2["Score + Confidence + Explanations + Issues"]
```
Les trois modes évaluent les mêmes 8 dimensions et renvoient le même score RAIL global. Ils diffèrent par leur profondeur et le niveau de détail renvoyé.
Les modèles de scoring fondamentaux de RAIL. Rapide (généralement moins d'une seconde) et conçu pour le scoring en temps réel en production.
Retourne : score global, scores par dimension et valeurs de confiance.
```python theme={null}
result = client.eval(content="Your text here", mode="basic")
# result.rail_score.score -> 7.6
# result.dimension_scores -> {fairness: {score: 7.7, confidence: 0.84}, ...}
```
Une analyse plus approfondie et détaillée du contenu. Prend quelques secondes et, en plus des scores, peut renvoyer une explication par dimension, des étiquettes de problèmes et des suggestions d'amélioration.
```python theme={null}
result = client.eval(
content="Your text here",
mode="deep",
include_explanations=True,
include_issues=True,
include_suggestions=True,
)
# result.dimension_scores["transparency"].explanation -> "The process is mostly clear, but..."
# result.dimension_scores["safety"].issues -> ["Potential phishing risks"]
```
Exécute le mode **basic** sur chaque requête et escalade vers le mode **deep** uniquement lorsqu'un problème réel est détecté – une dimension avec un score faible ou une faible confiance, ou un signal d'alerte. Le contenu propre reste rapide et bon marché ; le contenu qui nécessite du contrôle obtient automatiquement l'analyse plus approfondie.
```python theme={null}
result = client.eval(content="Your text here", mode="auto")
# result.resolved_mode -> "basic" (contenu propre – resté rapide)
# -> "deep" (problème détecté – escaladé)
# result.escalated -> False / True
```
`resolved_mode` et `escalated` dans le `result` de la réponse vous indiquent quel niveau a exécuté. Vous êtes facturé au niveau qui a réellement exécuté.
**Lequel utiliser :** optez pour le mode **basic** lorsque vous évaluez sur le chemin critique d'une requête en production et que vous voulez un verdict rapide. Optez pour le mode **deep** lorsque vous devez montrer à un relecteur *pourquoi* un contenu a obtenu un score faible, ou lorsque vous déboguez et ajustez une politique, car il renvoie des explications et des étiquettes de problèmes. Optez pour le mode **auto** lorsque vous voulez la vitesse du mode basic sur la plupart du trafic mais une analyse approfondie automatique sur le contenu qui en a besoin – sans décider à l'avance.
### La réponse
Chaque évaluation renvoie :
* `rail_score` : le score global (0–10), sa `confidence` et un `summary` d'une ligne.
* `dimension_scores` : un `score` et une `confidence` pour chacune des 8 dimensions. En mode deep, chacune porte aussi une `explanation` et des `issues` (et des `suggestions` lorsqu'elles sont demandées).
* `policy_outcome` : comment la [politique de votre application](/concepts/policy-engine) a jugé le résultat.
## Dimensions sélectives
```python theme={null}
result = client.eval(
content="Your text here",
mode="basic",
dimensions=["safety", "privacy", "reliability"],
)
```
## Pondérations personnalisées
Les pondérations doivent totaliser 100 :
```python theme={null}
result = client.eval(
content="Patient should take 500mg ibuprofen every 4 hours.",
mode="deep",
domain="healthcare",
weights={
"safety": 25, "privacy": 20, "reliability": 20,
"accountability": 15, "transparency": 10,
"fairness": 5, "inclusivity": 3, "user_impact": 2,
},
)
```
## Niveaux de score
Un score correspond à l'une des cinq tranches, d'**Excellent** (9.0–10.0) jusqu'à **Critical** (0.0–2.9). Consultez [Le framework RAIL](/concepts/rail-framework#score-tiers) pour le tableau complet et la signification de chaque tranche.
## Mise en cache
Les requêtes identiques renvoient des résultats mis en cache, de sorte que l'évaluation répétée d'un même contenu est rapide et n'est pas refacturée. Le mode basic met en cache pendant 5 minutes, le mode deep pendant 3 minutes.
Spécification complète de l'endpoint
Exemples de code Python