first (part 2: other directories)

ai-engine/features/upset_engine.py

@@ -0,0 +1,419 @@
+"""
+Upset Engine - Dev Avcısı Tespit Sistemi
+V9 Model için Galatasaray-Liverpool tarzı sürpriz maçları tespit eder.
+
+Faktörler:
+1. Atmosfer (Avrupa gecesi, taraftar baskısı)
+2. Motivasyon asimetrisi (küme düşme vs şampiyon)
+3. Yorgunluk (maç yoğunluğu, seyahat)
+4. Tarihsel upset pattern
+"""
+
+import os
+import sys
+from typing import Dict, Any, Optional, Tuple
+from dataclasses import dataclass, field
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+try:
+    import psycopg2
+    from psycopg2.extras import RealDictCursor
+except ImportError:
+    psycopg2 = None
+
+
+@dataclass
+class UpsetFactors:
+    """Upset potansiyelini etkileyen faktörler"""
+    atmosphere_score: float = 0.0      # Atmosfer etkisi (0-1)
+    motivation_score: float = 0.0       # Motivasyon asimetrisi (0-1)
+    fatigue_score: float = 0.0          # Yorgunluk farkı (0-1)
+    historical_upset_rate: float = 0.0  # Tarihsel upset oranı (0-1)
+    total_upset_potential: float = 0.0  # Toplam upset potansiyeli (0-1)
+    reasoning: list = field(default_factory=list)
+
+
+class UpsetEngine:
+    """
+    Favori takımın kaybedeceği maçları tespit eder.
+    Galatasaray-Liverpool tarzı sürprizleri yakalar.
+    """
+    
+    # Yüksek atmosferli stadyumlar (manuel tanımlı + hesaplanabilir)
+    HIGH_ATMOSPHERE_TEAMS = {
+        # Türkiye
+        "galatasaray", "fenerbahce", "besiktas", "trabzonspor",
+        # İngiltere
+        "liverpool", "newcastle", "leeds",
+        # Almanya
+        "dortmund", "union berlin",
+        # Yunanistan
+        "olympiacos", "panathinaikos", "aek athens",
+        # Arjantin
+        "boca juniors", "river plate",
+        # Diğer
+        "celtic", "rangers", "red star belgrade"
+    }
+    
+    # Avrupa kupaları (yüksek motivasyon)
+    EUROPEAN_COMPETITIONS = {
+        "şampiyonlar ligi", "champions league", "uefa champions league",
+        "avrupa ligi", "europa league", "uefa europa league",
+        "konferans ligi", "conference league", "uefa conference league"
+    }
+    
+    def __init__(self):
+        self.conn = None
+        self._connect_db()
+    
+    def _connect_db(self):
+        """Veritabanına bağlan"""
+        if psycopg2 is None:
+            return
+        
+        try:
+            from data.db import get_clean_dsn
+            self.conn = psycopg2.connect(get_clean_dsn())
+        except Exception as e:
+            print(f"[UpsetEngine] DB connection failed: {e}")
+            self.conn = None
+    
+    def _get_conn(self):
+        """Bağlantıyı kontrol et ve döndür"""
+        if self.conn is None or self.conn.closed:
+            self._connect_db()
+        return self.conn
+    
+    def calculate_atmosphere_score(
+        self, 
+        home_team_name: str,
+        league_name: str,
+        is_cup_match: bool = False
+    ) -> Tuple[float, list]:
+        """
+        Atmosfer skorunu hesapla.
+        Yüksek atmosferli stadyumlar upset potansiyelini artırır.
+        """
+        score = 0.0
+        reasons = []
+        
+        # Yüksek atmosferli takım mı?
+        home_lower = home_team_name.lower()
+        for team in self.HIGH_ATMOSPHERE_TEAMS:
+            if team in home_lower:
+                score += 0.25
+                reasons.append(f"🔥 {home_team_name} yüksek atmosferli stadyum")
+                break
+        
+        # Avrupa kupası mı?
+        league_lower = league_name.lower()
+        for comp in self.EUROPEAN_COMPETITIONS:
+            if comp in league_lower:
+                score += 0.20
+                reasons.append("🌟 Avrupa gecesi - ekstra motivasyon")
+                break
+        
+        # Kupa maçı mı? (tek maç eliminasyon)
+        if is_cup_match:
+            score += 0.10
+            reasons.append("🏆 Kupa maçı - her şey olabilir")
+        
+        return min(score, 1.0), reasons
+    
+    def calculate_motivation_score(
+        self,
+        home_position: int,
+        away_position: int,
+        home_points_to_safety: Optional[int] = None,
+        away_already_champion: bool = False,
+        total_teams: int = 20
+    ) -> Tuple[float, list]:
+        """
+        Motivasyon asimetrisini hesapla.
+        Alt sıradaki takımın üst sıradakine karşı ekstra motivasyonu.
+        """
+        score = 0.0
+        reasons = []
+        
+        # Pozisyon farkı
+        position_diff = 0
+        if away_position is not None and home_position is not None:
+            position_diff = away_position - home_position  # Negatif = deplasman daha iyi sırada
+        
+        # Küme düşme hattı vs üst sıra (en güçlü upset faktörü)
+        relegation_zone = total_teams - 3  # Son 3 takım
+        if home_position is not None and away_position is not None:
+            if home_position >= relegation_zone and away_position <= 3:
+                score += 0.30
+                reasons.append("⚔️ Hayatta kalma savaşı vs şampiyonluk adayı")
+            elif home_position >= relegation_zone:
+                score += 0.15
+                reasons.append("🔥 Ev sahibi küme düşme hattında - ekstra motivasyon")
+        elif home_position is not None and home_position >= relegation_zone:
+            score += 0.15
+            reasons.append("🔥 Ev sahibi küme düşme hattında - ekstra motivasyon")
+        
+        # Deplasman takımı zaten şampiyon mu?
+        if away_already_champion:
+            score += 0.20
+            reasons.append("😴 Deplasman takımı zaten şampiyon - motivasyon düşük")
+        
+        # Büyük pozisyon farkı (underdog evinde)
+        if position_diff < -10:
+            score += 0.15
+            reasons.append(f"📊 {abs(position_diff)} sıra fark - büyük maç heyecanı")
+        elif position_diff < -5:
+            score += 0.08
+        
+        return min(score, 1.0), reasons
+    
+    def calculate_fatigue_score(
+        self,
+        home_matches_last_14d: int = 0,
+        away_matches_last_14d: int = 0,
+        home_days_rest: int = 7,
+        away_days_rest: int = 7,
+        away_travel_km: float = 0
+    ) -> Tuple[float, list]:
+        """
+        Yorgunluk farkını hesapla.
+        Yorgun deplasman takımı = yüksek upset potansiyeli.
+        """
+        score = 0.0
+        reasons = []
+        
+        # Maç yoğunluğu farkı
+        match_diff = away_matches_last_14d - home_matches_last_14d
+        if match_diff >= 3:
+            score += 0.20
+            reasons.append(f"🏃 Deplasman {match_diff} maç daha fazla oynamış")
+        elif match_diff >= 2:
+            score += 0.10
+        
+        # Dinlenme süresi farkı
+        rest_diff = home_days_rest - away_days_rest
+        if rest_diff >= 4:
+            score += 0.15
+            reasons.append(f"💤 Ev sahibi {rest_diff} gün daha fazla dinlenmiş")
+        elif rest_diff >= 2:
+            score += 0.08
+        
+        # Uzun deplasman
+        if away_travel_km > 3000:
+            score += 0.15
+            reasons.append(f"✈️ Uzun deplasman ({int(away_travel_km)} km)")
+        elif away_travel_km > 1500:
+            score += 0.08
+        
+        return min(score, 1.0), reasons
+    
+    def get_historical_upset_rate(
+        self,
+        home_team_id: str,
+        before_date_ms: int,
+        lookback_matches: int = 20
+    ) -> Tuple[float, list]:
+        """
+        Ev sahibi takımın tarihsel upset oranını hesapla.
+        Üst sıradaki takımlara karşı galibiyetler.
+        """
+        reasons = []
+        
+        conn = self._get_conn()
+        if conn is None:
+            return 0.0, reasons
+        
+        try:
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            
+            # Ev sahibi olarak oynadığı ve sıralamada geride olduğu maçlar
+            query = """
+            WITH home_matches AS (
+                SELECT 
+                    m.id,
+                    m.score_home,
+                    m.score_away,
+                    m.home_team_id,
+                    m.away_team_id
+                FROM matches m
+                WHERE m.home_team_id = %s
+                    AND m.mst_utc < %s
+                    AND m.score_home IS NOT NULL
+                    AND m.score_away IS NOT NULL
+                ORDER BY m.mst_utc DESC
+                LIMIT %s
+            )
+            SELECT 
+                COUNT(*) as total,
+                SUM(CASE WHEN score_home > score_away THEN 1 ELSE 0 END) as wins
+            FROM home_matches
+            """
+            
+            cursor.execute(query, (home_team_id, before_date_ms, lookback_matches))
+            result = cursor.fetchone()
+            
+            if result and result['total'] > 0:
+                win_rate = result['wins'] / result['total']
+                # Ev sahibi kazanma oranı yüksekse, upset potansiyeli de yüksek
+                if win_rate > 0.5:
+                    rate = min((win_rate - 0.4) * 0.5, 0.3)
+                    reasons.append(f"📈 Güçlü ev sahibi performansı (%{int(win_rate*100)} kazanma)")
+                    return rate, reasons
+            
+            return 0.0, reasons
+            
+        except Exception as e:
+            print(f"[UpsetEngine] Historical query error: {e}")
+            return 0.0, reasons
+    
+    def calculate_upset_potential(
+        self,
+        home_team_name: str,
+        home_team_id: str,
+        away_team_name: str,
+        league_name: str,
+        home_position: int,
+        away_position: int,
+        match_date_ms: int,
+        is_cup_match: bool = False,
+        home_matches_last_14d: int = 2,
+        away_matches_last_14d: int = 2,
+        home_days_rest: int = 7,
+        away_days_rest: int = 7,
+        away_travel_km: float = 0,
+        total_teams: int = 20
+    ) -> UpsetFactors:
+        """
+        Tüm faktörleri birleştirerek upset potansiyelini hesapla.
+        
+        Returns:
+            UpsetFactors: Tüm faktörler ve toplam skor
+        """
+        factors = UpsetFactors()
+        all_reasons = []
+        
+        # 1. Atmosfer
+        atm_score, atm_reasons = self.calculate_atmosphere_score(
+            home_team_name, league_name, is_cup_match
+        )
+        factors.atmosphere_score = atm_score
+        all_reasons.extend(atm_reasons)
+        
+        # 2. Motivasyon
+        mot_score, mot_reasons = self.calculate_motivation_score(
+            home_position, away_position,
+            total_teams=total_teams
+        )
+        factors.motivation_score = mot_score
+        all_reasons.extend(mot_reasons)
+        
+        # 3. Yorgunluk
+        fat_score, fat_reasons = self.calculate_fatigue_score(
+            home_matches_last_14d, away_matches_last_14d,
+            home_days_rest, away_days_rest,
+            away_travel_km
+        )
+        factors.fatigue_score = fat_score
+        all_reasons.extend(fat_reasons)
+        
+        # 4. Tarihsel (sadece DB varsa)
+        hist_score, hist_reasons = self.get_historical_upset_rate(
+            home_team_id, match_date_ms
+        )
+        factors.historical_upset_rate = hist_score
+        all_reasons.extend(hist_reasons)
+        
+        # Toplam skor (weighted average)
+        factors.total_upset_potential = min(
+            factors.atmosphere_score * 0.25 +
+            factors.motivation_score * 0.35 +
+            factors.fatigue_score * 0.25 +
+            factors.historical_upset_rate * 0.15,
+            1.0
+        )
+        
+        factors.reasoning = all_reasons
+        
+        return factors
+    
+    def get_features(
+        self,
+        home_team_name: str,
+        home_team_id: str,
+        away_team_name: str,
+        league_name: str,
+        home_position: int,
+        away_position: int,
+        match_date_ms: int,
+        **kwargs
+    ) -> Dict[str, float]:
+        """
+        Model için feature dict döndür.
+        Training ve inference'da kullanılır.
+        """
+        factors = self.calculate_upset_potential(
+            home_team_name=home_team_name,
+            home_team_id=home_team_id,
+            away_team_name=away_team_name,
+            league_name=league_name,
+            home_position=home_position,
+            away_position=away_position,
+            match_date_ms=match_date_ms,
+            **kwargs
+        )
+        
+        return {
+            "upset_atmosphere": factors.atmosphere_score,
+            "upset_motivation": factors.motivation_score,
+            "upset_fatigue": factors.fatigue_score,
+            "upset_historical": factors.historical_upset_rate,
+            "upset_potential": factors.total_upset_potential,
+        }
+
+
+# Singleton instance
+_engine_instance = None
+
+def get_upset_engine() -> UpsetEngine:
+    """Singleton pattern ile engine döndür"""
+    global _engine_instance
+    if _engine_instance is None:
+        _engine_instance = UpsetEngine()
+    return _engine_instance
+
+
+# Test
+if __name__ == "__main__":
+    engine = get_upset_engine()
+    
+    # Galatasaray vs Liverpool örneği
+    factors = engine.calculate_upset_potential(
+        home_team_name="Galatasaray",
+        home_team_id="test-gs-id",
+        away_team_name="Liverpool",
+        league_name="UEFA Champions League",
+        home_position=12,
+        away_position=1,
+        match_date_ms=1700000000000,
+        is_cup_match=False,
+        away_matches_last_14d=5,
+        home_matches_last_14d=2,
+        away_days_rest=3,
+        home_days_rest=7,
+        away_travel_km=2800,
+        total_teams=20
+    )
+    
+    print("=" * 60)
+    print("GALATASARAY vs LIVERPOOL - UPSET ANALİZİ")
+    print("=" * 60)
+    print(f"🏟️ Atmosfer Skoru: {factors.atmosphere_score:.2f}")
+    print(f"💪 Motivasyon Skoru: {factors.motivation_score:.2f}")
+    print(f"😓 Yorgunluk Skoru: {factors.fatigue_score:.2f}")
+    print(f"📊 Tarihsel Skor: {factors.historical_upset_rate:.2f}")
+    print(f"\n🎯 TOPLAM UPSET POTANSİYELİ: {factors.total_upset_potential:.2f}")
+    print("\n📝 Sebepler:")
+    for reason in factors.reasoning:
+        print(f"   {reason}")