tag

Rapport2.typ

@@ -1,445 +0,0 @@
-// Using native Typst table instead of tablex for compatibility
-
-#set document(title: "Projet CS:GO - Pipeline MLOps", author: "Équipe MLOps")
-#set page(margin: 2cm, numbering: "1")
-#set text(size: 11pt)
-#set heading(numbering: "1.1")
-
-#align(center)[
-  #text(18pt, weight: "bold")[Projet CS:GO Esports Intelligence Platform]
-  #v(0.5cm)
-  #text(14pt)[Pipeline MLOps et Stratégie de Monitoring]
-  #v(0.3cm)
-  #line(length: 100%)
-  #v(0.5cm)
-  
-  #grid(
-    columns: (1fr, 1fr),
-    [*Équipe : Paul Roost, Axelle Desthombes, Alexis Bruneteau* ], [*Date :* #datetime.today().display()]
-  )
-  
-  #v(0.2cm)
-  *Dataset :* CS:GO Professional Matches (Kaggle - 25K+ matches) \
-  *Objectif :* Prédiction des résultats de matchs et optimisation des stratégies esports
-]
-
-#v(1cm)
-
-= Atelier 1 : Pipeline du Fil Rouge
-
-== Architecture Générale du Pipeline
-
-#figure(
-  image("images/pipeline2.svg", width: 60%),
-  caption: [Architecture complète du pipeline MLOps CS:GO]
-) <pipeline-arch>
-
-
-
-== Étapes Détaillées du Pipeline
-
-=== Collecte et Ingestion des Données
-
-*Sources de données :*
-- *HLTV.org* : Résultats historiques, classements équipes
-- *Steam API* : Données joueurs en temps réel  
-- *Tournament APIs* : Calendriers, formats de compétition
-
-*Pipeline d'ingestion automatisé avec Apache Airflow :*
-
-```python
-@dag(schedule_interval="@hourly", start_date=datetime(2024,1,1))
-def csgo_data_ingestion():
-    
-    extract_hltv_matches = PythonOperator(
-        task_id='extract_hltv',
-        python_callable=scrape_hltv_matches
-    )
-    
-    validate_data = PythonOperator(
-        task_id='validate_raw_data', 
-        python_callable=validate_match_schema
-    )
-    
-    store_s3 = PythonOperator(
-        task_id='store_to_s3',
-        python_callable=upload_to_s3
-    )
-    
-    extract_hltv_matches >> validate_data >> store_s3
-```
-
-=== Feature Engineering Multi-Niveaux
-
-#table(
-  columns: (2fr, 3fr),
-  stroke: 0.5pt,
-  [*Catégorie*], [*Features*],
-  [*Team-level*], [
-    • `recent_form_10_matches` - Ratio W/L récent \
-    • `map_pool_strength` - Win rate par map \
-    • `clutch_success_rate` - Performance clutch \
-    • `eco_round_conversion` - Gestion économique
-  ],
-  [*Context*], [
-    • `tournament_tier` - Prestige de l'événement \
-    • `prize_pool_amount` - Facteur de pression \
-    • `head_to_head_record` - Historique direct \
-    • `current_game_patch` - Version meta game
-  ],
-  [*Live*], [
-    • `current_score_difference` - Score en cours \
-    • `momentum_last_5_rounds` - Élan récent \
-    • `economy_advantage` - Avantage économique
-  ]
-)
-
-=== Entraînement Multi-Target
-
-Architecture d'apprentissage multitâche avec PyTorch :
-
-```python
-class CSGOPredictor(nn.Module):
-    def __init__(self, input_dim):
-        super().__init__()
-        self.shared_layers = nn.Sequential(
-            nn.Linear(input_dim, 256),
-            nn.ReLU(), 
-            nn.Dropout(0.3),
-            nn.Linear(256, 128)
-        )
-        
-        # Têtes spécialisées par tâche
-        self.match_winner = nn.Linear(128, 2)    # Classification binaire
-        self.final_score = nn.Linear(128, 2)     # Régression scores
-        self.total_maps = nn.Linear(128, 4)      # Nombre de maps
-        
-    def forward(self, x):
-        shared_repr = self.shared_layers(x)
-        return {
-            'match_winner': self.match_winner(shared_repr),
-            'final_score': self.final_score(shared_repr), 
-            'total_maps': self.total_maps(shared_repr)
-        }
-```
-
-== Automatisation et Points de Contrôle
-
-=== Stratégie d'Automatisation
-
-#table(
-  columns: (2fr, 1fr, 3fr),
-  stroke: 0.5pt,
-  [*Étape*], [*Status*], [*Justification*],
-  [*Ingestion données*], [AUTO], [Nouveaux matchs quotidiens, obsolescence rapide],
-  [*Feature Engineering*], [AUTO], [Features dépendent de données temps-réel],
-  [*Model Retraining*], [AUTO], [Meta game évolue (patches, transferts)],
-  [*Deployment*], [AUTO], [Évite erreurs humaines, rollback rapide],
-  [*Model Selection*], [MANUEL], [Décisions business complexes nécessitant expertise]
-)
-
-=== Points de Contrôle Critiques
-
-*Validation des Données :*
-```python
-def validate_match_data(df):
-    """Validation avant feature engineering"""
-    checks = [
-        ('schema_compliance', validate_schema(df)),
-        ('completeness', check_missing_values(df, threshold=0.05)),
-        ('consistency', validate_team_names(df)),
-        ('freshness', check_data_age(df, max_hours=24)),
-        ('volume', validate_daily_match_count(df, min_matches=50))
-    ]
-    
-    for check_name, result in checks:
-        if not result.passed:
-            raise DataValidationError(f"{check_name} failed")
-```
-
-*Validation des Performances :*
-```python
-def validate_model_performance(model, validation_data):
-    """Validation avant déploiement"""
-    metrics = evaluate_model(model, validation_data)
-    
-    # Seuils minimaux
-    assert metrics['accuracy'] > 0.65, "Accuracy insuffisante"
-    assert metrics['roi_betting'] > 1.05, "ROI non profitable"  
-    assert metrics['upset_detection'] > 0.20, "Détection upsets faible"
-    
-    return True
-```
-
-=== Difficultés Techniques et Solutions
-
-*Défi 1 : Concept Drift Extrême*
-
-Les mises à jour du jeu modifient significativement les stratégies et l'équilibre, ce qui peut rendre les modèles existants moins performants.
-
-*Solution :* Détection automatisée de drift + retraining d'urgence
-```python
-def detect_meta_shift(recent_matches, baseline):
-    """Détecte changements post-patch"""
-    map_rates = calculate_map_win_rates(recent_matches)
-    baseline_rates = baseline['map_win_rates']
-    
-    for map_name in map_rates:
-        ks_stat, p_value = ks_2samp(map_rates[map_name], 
-                                   baseline_rates[map_name])
-        if p_value < 0.01:  # Drift significatif
-            return True
-    return False
-```
-
-*Défi 2 : Cold Start Problem*
-
-Les nouvelles équipes ou changements de composition ne disposent pas d'historique suffisant pour l'entraînement.
-
-*Solution :* Transfer learning via embeddings joueurs
-```python
-def handle_cold_start_team(roster, player_db):
-    """Prédictions via similarité joueurs"""
-    team_embedding = [player_db.get_embedding(p.id) for p in roster]
-    similar_teams = find_similar_teams(team_embedding, top_k=5)
-    return weighted_prediction_from_similar(similar_teams)
-```
-
-#pagebreak()
-
-= Atelier 2 : Expériences et Monitoring
-
-== Tracking des Expériences avec MLflow
-
-=== Configuration et Logging Structuré
-
-```python
-mlflow.set_tracking_uri("http://mlflow-server:5000")
-mlflow.set_experiment("csgo-match-prediction")
-
-def train_and_log_experiment(config):
-    with mlflow.start_run(run_name=f"csgo-v{config.version}"):
-        
-        # Hyperparamètres
-        mlflow.log_params({
-            "model_type": config.model_type,
-            "learning_rate": config.lr,
-            "batch_size": config.batch_size,
-            "data_version": config.data_version
-        })
-        
-        # Métriques par époque
-        for epoch in range(config.epochs):
-            train_loss = train_one_epoch(model, train_loader)
-            val_metrics = evaluate_model(model, val_loader)
-            
-            mlflow.log_metrics({
-                "train_loss": train_loss,
-                "val_accuracy": val_metrics['accuracy'],
-                "betting_roi": val_metrics['roi'],
-                "upset_detection": val_metrics['upset_rate']
-            }, step=epoch)
-            
-        # Artefacts finaux
-        mlflow.pytorch.log_model(model, "model")
-        mlflow.log_artifacts("evaluation_plots/")
-```
-
-=== Métriques Trackées
-
-#table(
-  columns: (2fr, 3fr),
-  stroke: 0.5pt,
-  [*Catégorie*], [*Métriques*],
-  [*Performance ML*], [
-    • Accuracy, Precision, Recall, F1-Score \
-    • ROC-AUC, Calibration Error \
-    • Performance par segment (tier tournoi)
-  ],
-  [*Business*], [
-    • ROI betting, Profit/Loss \
-    • Sharpe Ratio, Upset Detection Rate \
-    • User Engagement, Revenue Impact
-  ],
-  [*Computational*], [
-    • Training Time, Inference Latency \
-    • Model Size, Memory Usage \
-    • API Response Time
-  ]
-)
-
-== Stratégie de Monitoring Complète
-
-=== Métriques de Surveillance Multi-Niveaux
-
-*Surveillance de la qualité des données :*
-```python
-class DataMonitoring:
-    def monitor_data_quality(self, new_batch):
-        metrics = {}
-        
-        # Volume et couverture
-        metrics['daily_match_count'] = len(new_batch)
-        metrics['team_coverage'] = new_batch['team_name'].nunique()
-        
-        # Qualité
-        metrics['missing_rate'] = new_batch.isnull().mean().mean()
-        metrics['duplicates'] = new_batch.duplicated().sum()
-        
-        # Drift distribution
-        for col in ['team_ranking', 'match_duration']:
-            drift = calculate_drift_score(new_batch[col], baseline[col])
-            metrics[f'{col}_drift'] = drift
-            
-        return metrics
-```
-
-*Model Performance Monitoring :*
-```python
-def monitor_model_performance(predictions, actuals):
-    """Monitoring performance temps-réel"""
-    rolling_metrics = {}
-    
-    # Fenêtres glissantes
-    for window in [1, 7, 30]:  # jours
-        recent = get_recent_data(window)
-        rolling_metrics[f'accuracy_{window}d'] = accuracy_score(
-            recent['actual'], recent['predicted']
-        )
-        rolling_metrics[f'roi_{window}d'] = calculate_roi(
-            recent['predictions'], recent['outcomes']
-        )
-    
-    return rolling_metrics
-```
-
-=== Système d'Alertes Intelligent
-
-#table(
-  columns: (1fr, 2fr, 2fr),
-  stroke: 0.5pt,
-  [*Sévérité*], [*Seuils*], [*Actions*],
-  [*CRITIQUE*], [
-    • Accuracy 7j \< 60% \
-    • ROI 7j \< 100% \
-    • API errors \> 5%
-  ], [
-    • PagerDuty + Slack \
-    • Email équipe oncall \
-    • Rollback automatique
-  ],
-  [*WARNING*], [
-    • Accuracy trending ↓ \
-    • Concept drift p\<0.05 \
-    • Latency \> 300ms
-  ], [
-    • Slack \#alerts \
-    • Email ML team \
-    • Investigation requise
-  ],
-  [*INFO*], [
-    • Nouveaux tournaments \
-    • Performance updates \
-    • System health
-  ], [
-    • Slack \#monitoring \
-    • Dashboard updates
-  ]
-)
-
-=== Dashboards et Rapports
-
-*Dashboard Temps-Réel (Grafana) :*
-
-- *Model Performance* : Accuracy, ROI, Calibration trends
-- *Data Pipeline Health* : Volume, freshness, quality scores  
-- *API Performance* : Latency P95, request rate, error rate
-- *Business Metrics* : Revenue impact, user engagement
-
-*Rapports Hebdomadaires Automatisés :*
-
-```python
-class WeeklyReportGenerator:
-    def generate_performance_report(self, week_start, week_end):
-        sections = [
-            self.executive_summary(),      # KPIs clés
-            self.model_performance(),      # Analyse détaillée
-            self.business_impact(),        # Valeur générée  
-            self.technical_health(),       # Infrastructure
-            self.recommendations()         # Actions recommandées
-        ]
-        return self.compile_html_report(sections)
-```
-
-== Architecture de Monitoring Production
-
-=== Alerting Multi-Canal
-
-```python
-class AlertManager:
-    def __init__(self):
-        self.channels = {
-            'slack': SlackNotifier(SLACK_WEBHOOK),
-            'email': EmailNotifier(EMAIL_CONFIG), 
-            'pagerduty': PagerDutyNotifier(PAGERDUTY_KEY)
-        }
-        
-    def send_alert(self, alert):
-        if alert['severity'] == 'CRITICAL':
-            // Alertes critiques sur tous les canaux
-            self.channels['pagerduty'].send(alert)
-            self.channels['slack'].send_critical(alert)
-            self.channels['email'].send_oncall(alert)
-        elif alert['severity'] == 'WARNING':
-            // Warnings vers Slack et email
-            self.channels['slack'].send_warning(alert)
-            self.channels['email'].send_team(alert)
-```
-
-=== Runbooks d'Incident
-
-*Alerte Critique : Accuracy < 60%*
-
-1. *Actions Immédiates (0-15min)*
-   - Vérifier qualité des données récentes
-   - Identifier changements meta/tournois  
-   - Rollback si accuracy < 55%
-
-2. *Investigation (15-60min)*
-   - Analyse drift sur données récentes
-   - Comparaison prédictions vs résultats
-   - Validation pipeline features
-
-3. *Résolution (1-4h)*
-   - Retraining d'urgence si drift détecté
-   - Fix pipeline si problème data quality
-   - Rollback si problème infrastructure
-
-= Conclusion
-
-L'architecture MLOps développée pour ce projet CS:GO présente plusieurs caractéristiques importantes :
-
-*Architecture de production robuste :*
-- Apprentissage multi-tâches permettant des prédictions variées selon les besoins métier
-- Service en temps réel respectant les contraintes de latence
-- Gestion de la dérive conceptuelle liée à l'évolution du meta-jeu
-- Surveillance complète des données, modèles et métriques business
-
-*Mesure de la valeur métier :*
-- Suivi du retour sur investissement pour les applications de paris et fantasy leagues
-- Métriques d'engagement utilisateur pour optimiser la rétention
-- Impact sur le chiffre d'affaires pour justifier les investissements
-
-*Fiabilité opérationnelle :*
-- Retour en arrière automatique en cas de dégradation des performances
-- Système d'alertes multi-canaux pour une réaction rapide
-- Procédures documentées pour la résolution d'incidents
-- Plan de continuité d'activité pour les événements critiques
-
-Ce travail démontre l'application des principes MLOps modernes à un domaine spécialisé, en mettant l'accent sur la création de valeur métier et la fiabilité opérationnelle.
-
-#align(center)[
-  #line(length: 50%)
-  #v(0.3cm)
-  *Équipe MLOps - Projet CS:GO Intelligence Platform*
-]