| import { |
| buildRankingRows, |
| compareRankingRows, |
| rankingRowsToCsv, |
| rankingScopeGroups |
| } from '$lib/data/ranking'; |
| import { toolsDataGroups, toolsRowsToCsv } from '$lib/data/tools'; |
| import { |
| buildMatrixGroups, |
| buildMatrixRows, |
| detailMatrixRowsToCsv, |
| detailMetricValue, |
| visibleDetailMatrixDatasets |
| } from '$lib/data/details'; |
| import type { DetailsDataset, DetailsDatasetMatrixCell } from '$lib/types/details-data'; |
| import type { DetailMetric, MatrixDataset } from '$lib/types/details'; |
| import type { LocalizedString } from '$lib/types/i18n'; |
| import type { GuardModel } from '$lib/types/leaderboard'; |
| import type { RankingDataset } from '$lib/types/ranking-data'; |
| import type { ToolsDataset } from '$lib/types/tools-data'; |
|
|
| const rankingScope = 'all'; |
| const rankingSortKey = 'integral'; |
| const rankingSortDirection = 'desc'; |
| const detailsMatrixMetric: DetailMetric = 'score'; |
| const detailsMatrixSortDataset = null; |
| const detailsMatrixSortDirection = -1; |
|
|
| function localizedEn(value: LocalizedString | null | undefined, fallback: string) { |
| return value?.en ?? fallback; |
| } |
|
|
| function modelKey(model: GuardModel) { |
| return model.modelId ?? model.name; |
| } |
|
|
| function csvNumberValue(value: number | null | undefined, digits = 4) { |
| return typeof value === 'number' && Number.isFinite(value) ? Number(value.toFixed(digits)) : null; |
| } |
|
|
| function exportMatrixDatasets(dataset: DetailsDataset): MatrixDataset[] { |
| return dataset.datasetMatrix.datasets.map((item) => ({ |
| id: item.id, |
| name: item.id, |
| group: localizedEn(item.groupLabel, item.groupId), |
| sourceGroup: localizedEn(item.groupLabel, item.groupId), |
| label: localizedEn(item.label, item.id), |
| language: item.language |
| })); |
| } |
|
|
| function exportMatrixGroups(dataset: DetailsDataset) { |
| const matrixDatasets = exportMatrixDatasets(dataset); |
| const visibleDatasets = visibleDetailMatrixDatasets(matrixDatasets, dataset.allGroups, 'any'); |
| return buildMatrixGroups(visibleDatasets); |
| } |
|
|
| function exportMatrixRows(dataset: DetailsDataset) { |
| return buildMatrixRows( |
| '', |
| detailsMatrixMetric, |
| detailsMatrixSortDataset, |
| detailsMatrixSortDirection, |
| dataset.models, |
| exportMatrixDatasets(dataset), |
| dataset.datasetMatrix.cellsByModelId |
| ); |
| } |
|
|
| export function rankingExportRows(dataset: RankingDataset) { |
| const groups = rankingScopeGroups(rankingScope, dataset); |
| const rows = buildRankingRows(groups, true, dataset.models, dataset.allGroups.length); |
|
|
| return [...rows].sort((a, b) => compareRankingRows(a, b, rankingSortKey, rankingSortDirection)); |
| } |
|
|
| export function rankingExportCsv(dataset: RankingDataset) { |
| return rankingRowsToCsv(rankingExportRows(dataset)); |
| } |
|
|
| export function rankingExportJson(dataset: RankingDataset) { |
| return { |
| snapshotId: dataset.snapshotId, |
| snapshotDate: dataset.snapshotDate, |
| generatedAt: dataset.generatedAt, |
| scope: rankingScope, |
| sort: { |
| key: rankingSortKey, |
| direction: rankingSortDirection |
| }, |
| rows: rankingExportRows(dataset).map((row, index) => ({ |
| rank: index + 1, |
| model: row.model.name, |
| size: row.size, |
| integral: csvNumberValue(row.integral), |
| min_group: csvNumberValue(row.minGroup), |
| overall_fpr: csvNumberValue(row.fpr), |
| overall_fnr: csvNumberValue(row.fnr), |
| overall_f1: csvNumberValue(row.f1), |
| p95_ms: csvNumberValue(row.p95, 1), |
| run_date: row.model.runDate |
| })) |
| }; |
| } |
|
|
| export function detailsMatrixExportCsv(dataset: DetailsDataset) { |
| return detailMatrixRowsToCsv( |
| exportMatrixRows(dataset), |
| exportMatrixGroups(dataset), |
| detailsMatrixMetric, |
| dataset.datasetMatrix.cellsByModelId |
| ); |
| } |
|
|
| export function detailsMatrixExportJson(dataset: DetailsDataset) { |
| const groups = exportMatrixGroups(dataset); |
| const matrixRows = exportMatrixRows(dataset); |
| const matrixDatasets = groups.flatMap((group) => group.datasets); |
| const cellsByModelId: Record<string, Record<string, DetailsDatasetMatrixCell>> = dataset |
| .datasetMatrix.cellsByModelId; |
|
|
| return { |
| snapshotId: dataset.snapshotId, |
| snapshotDate: dataset.snapshotDate, |
| generatedAt: dataset.generatedAt, |
| metric: detailsMatrixMetric, |
| datasets: matrixDatasets.map((item) => ({ |
| id: item.id, |
| group: item.group, |
| label: item.label, |
| language: item.language |
| })), |
| rows: matrixRows.map((model, index) => ({ |
| rank: index + 1, |
| model: model.name, |
| organization: model.org, |
| size: model.params, |
| integral: csvNumberValue(model.integral), |
| metric: detailsMatrixMetric, |
| values: Object.fromEntries( |
| matrixDatasets.map((item) => [ |
| item.id, |
| csvNumberValue( |
| detailMetricValue(cellsByModelId[modelKey(model)]?.[item.id], detailsMatrixMetric) |
| ) |
| ]) |
| ) |
| })) |
| }; |
| } |
|
|
| function toolsExportGroups(dataset: ToolsDataset) { |
| return toolsDataGroups(dataset.models, dataset.allGroups); |
| } |
|
|
| export function toolsExportCsv(dataset: ToolsDataset) { |
| return toolsRowsToCsv(dataset.models, toolsExportGroups(dataset)); |
| } |
|
|
| export function toolsExportJson(dataset: ToolsDataset) { |
| const groups = toolsExportGroups(dataset); |
|
|
| return { |
| snapshotId: dataset.snapshotId, |
| snapshotDate: dataset.snapshotDate, |
| generatedAt: dataset.generatedAt, |
| groups, |
| rows: dataset.models.flatMap((model) => |
| groups.map((group) => { |
| const cell = model.groups[group] ?? null; |
|
|
| return { |
| model: model.name, |
| group, |
| score: csvNumberValue(cell?.score), |
| fnr: csvNumberValue(cell?.fnr), |
| fpr: csvNumberValue(cell?.fpr), |
| f1: csvNumberValue(cell?.f1) |
| }; |
| }) |
| ) |
| }; |
| } |
|
|
