{}

Confusion Matrix (Normalized)

{}

Predicted Classes

{}

{labels.map((label, ci) =>

{labelDisplayNames[label] ?? label}

)} {} {labels.map((rowLabel, ri) => [

{labelDisplayNames[rowLabel] ?? rowLabel}

, ...labels.map((colLabel, ci) => { const pct = (matrix[ri][ci] ?? 0) * 100; return

{formatValue(pct)}

; })]).flat()} {}

{displayFormat === "fraction" ? "0.0" : "0%"}

{palette.map((color, idx) =>

)}

{displayFormat === "fraction" ? "1.0" : "100%"}

; }; export const MultiClassClassificationReport = ({report, labels: labelsProp, labelDisplayNames: labelDisplayNamesProp = {}, decimals = 4, maxWidth = 560, showConfusionMatrix = true}) => { const parseReport = reportStr => { const lines = reportStr.trim().split('\n').filter(line => line.trim()); const result = { classes: [], accuracy: null, macroAvg: null, weightedAvg: null, totalSupport: null }; for (const line of lines) { const parts = line.trim().split(/\s+/); if (parts[0] === 'precision') continue; if (parts[0] === 'accuracy') { result.accuracy = parseFloat(parts[1]); result.totalSupport = parseInt(parts[2], 10); continue; } if (parts[0] === 'macro' && parts[1] === 'avg') { result.macroAvg = { precision: parseFloat(parts[2]), recall: parseFloat(parts[3]), f1: parseFloat(parts[4]), support: parseInt(parts[5], 10) }; continue; } if (parts[0] === 'weighted' && parts[1] === 'avg') { result.weightedAvg = { precision: parseFloat(parts[2]), recall: parseFloat(parts[3]), f1: parseFloat(parts[4]), support: parseInt(parts[5], 10) }; continue; } if (parts.length >= 5) { const support = parseInt(parts[parts.length - 1], 10); const f1 = parseFloat(parts[parts.length - 2]); const recall = parseFloat(parts[parts.length - 3]); const precision = parseFloat(parts[parts.length - 4]); if (!isNaN(support) && !isNaN(f1) && !isNaN(recall) && !isNaN(precision)) { const name = parts.slice(0, parts.length - 4).join(' '); result.classes.push({ name, precision, recall, f1, support }); } } } return result; }; const buildConfusionMatrix = classes => { const n = classes.length; const tp = classes.map(c => c.recall * c.support); const predTotal = classes.map((c, i) => c.precision > 0 ? tp[i] / c.precision : 0); const fpTotal = classes.map((c, i) => Math.max(0, predTotal[i] - tp[i])); const fnTotal = classes.map((c, i) => Math.max(0, c.support - tp[i])); const cm = Array.from({ length: n }, () => Array(n).fill(0)); for (let i = 0; i < n; i++) cm[i][i] = tp[i]; if (n > 1) { const rowTargets = fnTotal; const colTargets = fpTotal; const offDiag = Array.from({ length: n }, () => Array(n).fill(0)); for (let i = 0; i < n; i++) { for (let j = 0; j < n; j++) { if (i !== j) offDiag[i][j] = 1; } } for (let iter = 0; iter < 50; iter++) { for (let i = 0; i < n; i++) { const rowSum = offDiag[i].reduce((a, v, j) => i !== j ? a + v : a, 0); if (rowSum > 0 && rowTargets[i] > 0) { const factor = rowTargets[i] / rowSum; for (let j = 0; j < n; j++) if (i !== j) offDiag[i][j] *= factor; } else { for (let j = 0; j < n; j++) if (i !== j) offDiag[i][j] = 0; } } for (let j = 0; j < n; j++) { const colSum = offDiag.reduce((a, row, i) => i !== j ? a + row[j] : a, 0); if (colSum > 0 && colTargets[j] > 0) { const factor = colTargets[j] / colSum; for (let i = 0; i < n; i++) if (i !== j) offDiag[i][j] *= factor; } else { for (let i = 0; i < n; i++) if (i !== j) offDiag[i][j] = 0; } } } for (let i = 0; i < n; i++) { for (let j = 0; j < n; j++) { if (i !== j) cm[i][j] = Math.max(0, offDiag[i][j]); } } } const normalized = cm.map((row, i) => { const rowSum = classes[i].support; return row.map(v => rowSum > 0 ? v / rowSum : 0); }); return normalized; }; let labelsArr, labelDisplayNames; try { labelsArr = typeof labelsProp === 'string' ? JSON.parse(labelsProp) : labelsProp; labelDisplayNames = typeof labelDisplayNamesProp === 'string' ? JSON.parse(labelDisplayNamesProp) : labelDisplayNamesProp; } catch (e) { return

MultiClassClassificationReport: JSON parse error - {e.message}

; } const parsed = parseReport(report); if (parsed.classes.length < 2) { return

MultiClassClassificationReport: Could not parse report. Expected at least 2 classes.

; } let orderedClasses = parsed.classes; if (Array.isArray(labelsArr) && labelsArr.length > 0) { const classMap = {}; for (const c of parsed.classes) classMap[c.name] = c; orderedClasses = labelsArr.map(l => classMap[l]).filter(Boolean); } const classLabels = orderedClasses.map(c => c.name); const confusionMatrix = buildConfusionMatrix(orderedClasses); const rowStyle = { borderBottom: "1px solid rgba(148, 163, 184, 0.3)" }; const cellStyle = { padding: "0.5rem 0.125rem" }; const centerCellStyle = { textAlign: "center", padding: "0.5rem 0.125rem" }; const fmtMetric = v => { const n = Number(v); return Number.isFinite(n) ? n.toFixed(decimals) : "—"; }; return

{orderedClasses.map(cls => )}

	Precision	Recall	F1-Score
{labelDisplayNames?.[cls.name] ?? cls.name}	{fmtMetric(cls.precision)}	{fmtMetric(cls.recall)}	{fmtMetric(cls.f1)}

{showConfusionMatrix && 3 ? 3 : decimals} />}

; }; export const DefinitionCard = ({children}) => { return

{children}

; }; export const Scale = ({low, mid, high, lowLabel = "Low", midLabel = "Mid", highLabel = "High", lowDescription, midDescription, highDescription, midColor = "yellow", inverted = false}) => { const lowColor = inverted ? "green" : "red"; const highColor = inverted ? "red" : "green"; const gradientId = inverted ? "greenToRed" : "redToGreen"; return

{low}

{mid &&

{mid}

}

{high}

{lowLabel}

{lowDescription &&

{lowDescription}

}

{mid &&

{midLabel}

{midDescription &&

{midDescription}

}

{highLabel}

{highDescription &&

{highDescription}

}

; }; Tone Analysis classifies the emotional tone of responses into distinct categories to ensure appropriate emotional context. ## Emotion categories

Available Emotion Categories

Balanced and objective tone Happiness and delight Affection and warmth Anxiety and concern Astonishment and wonder Melancholy and grief Frustration and rage Irritation and displeasure Uncertainty and puzzlement ## Calculation method Tone analysis is computed through a specialized process: The analysis system utilizes a Small Language Model (SLM) trained on a comprehensive combination of open-source and internal datasets to accurately classify emotional tones across multiple categories. The classification system demonstrates strong reliability with an 80% accuracy rate when evaluated against the GoEmotions validation dataset, a widely-used benchmark for emotion detection. ## Optimizing your AI system

Managing Tone in Your System

When optimizing the emotional tone of your system, consider these approaches:

Define tone preferences: Set appropriate emotional tones for different contexts and user interactions.

Implement tone filters: Discourage undesirable emotional responses while promoting preferred tones.

Recognize and categorize the emotional tone of responses to align with user preferences and context, ensuring appropriate emotional engagement in AI interactions. ## Performance Benchmarks We evaluated the Tone classification model against human expert labels on an internal dataset spanning 8 emotion categories. | Model | Macro F1 | | :--------------------- | :------: | | GPT-4.1 | 0.97 | | GPT-4.1 Mini | 0.94 | | Gemini 3 Flash Preview | 0.97 | | Claude Sonnet 4.5 | 0.83 | ### GPT-4.1 Classification Report Benchmarks based on internal evaluation dataset. Performance may vary by use case. ## Related Resources If you would like to dive deeper or start implementing Tone, check out the following resources: ### Examples * [Tone Examples](https://app.galileo.ai) - Log in and explore the "Tone" Log Stream in the "Preset Metric Examples" Project to see this metric in action.