Système de Recommandation Avancé - Documentation Technique

Critères Utilisateur → API Gateway → Service-Selection →
Algorithm Scoring → JSON Response → Angular → ECharts Rendering

def calculate_ethical_score(dataset: Dataset) -> float:
    """Calcule le score éthique basé sur 10 critères binaires"""
    criteria = [
        dataset.informed_consent,
        dataset.transparency,
        dataset.user_control,
        dataset.equity_non_discrimination,
        dataset.security_measures_in_place,
        dataset.data_quality_documented,
        dataset.anonymization_applied,
        dataset.record_keeping_policy_exists,
        dataset.purpose_limitation_respected,
        dataset.accountability_defined
    ]

    respected_criteria = sum(1 for criterion in criteria if criterion)
    return respected_criteria / len(criteria)

def calculate_technical_score(dataset: Dataset) -> float:
    """Score technique = Documentation + Qualité + Taille/Richesse"""

    # Documentation (30% du score technique)
    doc_score = 0.0
    if dataset.metadata_provided_with_dataset:
        doc_score += 0.15
    if dataset.external_documentation_available:
        doc_score += 0.15

    # Qualité des données (40% du score technique)
    quality_score = 0.0

    # Valeurs manquantes
    if dataset.missing_values_percentage is not None:
        missing_score = 0.2 * (100 - dataset.missing_values_percentage) / 100
        quality_score += max(0, missing_score)
    elif not dataset.has_missing_values:
        quality_score += 0.2

    # Dataset pré-splitté
    if dataset.is_split:
        quality_score += 0.2

    # Taille et richesse (30% du score technique)
    size_score = 0.0

    # Score logarithmique des instances
    if dataset.instances_number and dataset.instances_number > 0:
        log_instances = math.log10(dataset.instances_number)
        instances_score = min(1, max(0, (log_instances - 2) / 3)) * 0.15
        size_score += instances_score

    # Score des features (optimal entre 10-100)
    if dataset.features_number:
        if 10 <= dataset.features_number <= 100:
            features_score = 0.15
        elif dataset.features_number > 100:
            features_score = 0.15 * max(0.5, 1 - (dataset.features_number - 100) / 1000)
        else:  # < 10
            features_score = 0.15 * dataset.features_number / 10
        size_score += features_score

    total_score = doc_score + quality_score + size_score
    max_possible = 0.3 + 0.4 + 0.3  # 1.0

    return total_score / max_possible

def calculate_popularity_score(dataset: Dataset) -> float:
    """Score basé sur les citations académiques (échelle log)"""
    if not dataset.citations or dataset.citations <= 0:
        return 0.0

    # Échelle logarithmique : 1000+ citations = score maximal
    log_citations = math.log10(dataset.citations)
    return min(1.0, max(0.0, log_citations / 3.0))

private getEChartsOption() {
  const datasets = this.datasets;
  const weights = this.weights;

  // Préparation des données au format ECharts [x, y, value]
  const data: any[] = [];
  const yAxisData: string[] = [];
  const xAxisData: string[] = [];

  // Construction des axes
  datasets.forEach((dataset, datasetIndex) => {
    yAxisData.push(dataset.dataset_name);

    weights.forEach((weight, weightIndex) => {
      if (datasetIndex === 0) {
        xAxisData.push(this.formatCriterionName(weight.criterion_name));
      }

      const score = this.getDatasetScore(dataset, weight.criterion_name);
      data.push([weightIndex, datasetIndex, score]);
    });
  });

  return {
    tooltip: {
      position: 'top',
      formatter: (params: any) => {
        const dataset = datasets[params.data[1]];
        const weight = weights[params.data[0]];
        const score = params.data[2];

        return `
          <div style="padding: 10px;">
            <strong>${dataset.dataset_name}</strong><br/>
            <strong>${this.formatCriterionName(weight.criterion_name)}</strong><br/>
            Score: <strong>${(score * 100).toFixed(1)}%</strong><br/>
            Poids: ${(weight.weight * 100).toFixed(0)}%<br/>
            Instances: ${dataset.instances_number?.toLocaleString() || 'N/A'}<br/>
            Features: ${dataset.features_number || 'N/A'}
          </div>
        `;
      }
    },

    grid: {
      height: '80%',
      top: '10%',
      left: '20%',
      right: '10%'
    },

    xAxis: {
      type: 'category',
      data: xAxisData,
      splitArea: { show: true },
      axisLabel: {
        rotate: 45,
        fontSize: 11
      }
    },

    yAxis: {
      type: 'category',
      data: yAxisData,
      splitArea: { show: true },
      axisLabel: { fontSize: 11 }
    },

    visualMap: {
      min: 0,
      max: 1,
      calculable: true,
      orient: 'horizontal',
      left: 'center',
      bottom: '5%',
      inRange: {
        color: ['#d73027', '#fc8d59', '#fee08b', '#91cf60', '#4575b4']
      },
      text: ['Excellent', 'Faible'],
      textStyle: { fontSize: 10 }
    },

    series: [{
      name: 'Scores',
      type: 'heatmap',
      data: data,
      emphasis: {
        itemStyle: {
          shadowBlur: 10,
          shadowColor: 'rgba(0, 0, 0, 0.5)'
        }
      }
    }]
  };
}

private setupResizeHandler(): void {
  if (typeof window !== 'undefined') {
    const resizeHandler = () => {
      if (this.chartInstance && !this.chartInstance.isDisposed()) {
        this.chartInstance.resize();
      }
    };

    window.addEventListener('resize', resizeHandler);

    // Cleanup dans ngOnDestroy
    this.resizeListener = () => {
      window.removeEventListener('resize', resizeHandler);
    };
  }
}

private async initializeECharts(): Promise<void> {
  try {
    this.isEChartsLoading = true;
    this.echarts = await this.loadECharts();
    await this.initChart();
  } catch (error) {
    console.error('Erreur lors du chargement d\'ECharts:', error);
    this.showFallbackMessage();
  } finally {
    this.isEChartsLoading = false;
  }
}

private showFallbackMessage(): void {
  // Affichage d'un message de fallback ou composant alternatif
}

// Limitation à 20 datasets max pour la visualisation
private optimizeDataForVisualization(datasets: any[]): any[] {
  if (datasets.length <= 20) {
    return datasets;
  }

  // Prendre les 20 datasets avec les meilleurs scores
  return datasets
    .sort((a, b) => b.score - a.score)
    .slice(0, 20);
}

// Debounce des updates lors des changements de poids
private debouncedUpdate = debounce((datasets: any[], weights: any[]) => {
  this.updateChart(datasets, weights);
}, 300);

ngOnDestroy(): void {
  if (this.chartInstance && !this.chartInstance.isDisposed()) {
    this.chartInstance.dispose();
  }

  if (this.resizeListener) {
    this.resizeListener();
  }
}

describe('RecommendationHeatmapComponent', () => {
  let component: RecommendationHeatmapComponent;
  let fixture: ComponentFixture<RecommendationHeatmapComponent>;

  beforeEach(() => {
    TestBed.configureTestingModule({
      declarations: [RecommendationHeatmapComponent],
      imports: [MatProgressSpinnerModule]
    });
  });

  it('should load ECharts via CDN', async () => {
    await component.loadECharts();
    expect((window as any).echarts).toBeDefined();
  });

  it('should format dataset data correctly for ECharts', () => {
    const mockDatasets = [...];
    const mockWeights = [...];

    component.datasets = mockDatasets;
    component.weights = mockWeights;

    const option = component.getEChartsOption();
    expect(option.series[0].data).toHaveLength(6); // 2 datasets × 3 critères
  });
});

def test_scoring_algorithm_integration():
    """Test l'algorithme complet de scoring"""

    # Dataset de test
    dataset = Dataset(
        dataset_name="Test Dataset",
        ethical_score=0.8,
        technical_score=0.9,
        popularity_score=0.7,
        instances_number=50000,
        features_number=25
    )

    # Poids de test
    weights = [
        Weight(criterion_name="ethical_score", weight=0.4),
        Weight(criterion_name="technical_score", weight=0.4),
        Weight(criterion_name="popularity_score", weight=0.2)
    ]

    # Calcul du score final
    final_score = calculate_final_score(dataset, weights)

    expected_score = (0.8 * 0.4 + 0.9 * 0.4 + 0.7 * 0.2) / 1.0
    assert abs(final_score - expected_score) < 0.001

# Configuration ECharts
ECHARTS_CDN_URL=https://cdn.jsdelivr.net/npm/echarts@5.4.3/dist/echarts.min.js
HEATMAP_MAX_DATASETS=20
HEATMAP_UPDATE_DEBOUNCE_MS=300

# Configuration scoring
DEFAULT_ETHICAL_WEIGHT=0.4
DEFAULT_TECHNICAL_WEIGHT=0.4
DEFAULT_POPULARITY_WEIGHT=0.2

// tsconfig.json
{
  "compilerOptions": {
    "allowSyntheticDefaultImports": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}

// global.d.ts
declare global {
  interface Window {
    echarts: any;
  }
}

export {};