gg2

gg
2026-05-24 17:29:31 +03:00 · 2026-05-24 02:58:53 +03:00 · 2026-05-24 02:49:08 +03:00 · 2026-05-24 02:44:52 +03:00 · 2026-05-24 02:43:10 +03:00 · 2026-05-24 02:30:14 +03:00
536 changed files with 266563 additions and 12 deletions
@@ -0,0 +1,27 @@
+node_modules
+dist
+.git
+.env
+.env.*
+*.backup
+*.dump
+ai-engine/
+venv/
+__pycache__/
+*.pyc
+
+# IDE files
+.vscode/
+.idea/
+
+# Ignore test coverage and log files
+coverage/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Uploads
+uploads/
+public/uploads/
@@ -11,13 +11,27 @@ jobs:
      - name: Kodu Cek
        uses: actions/checkout@v4

-      - name: Docker Build
+      - name: Docker Build (Backend)
        run: docker build -t iddaai-be:latest .

-      - name: Eski Konteyneri Sil
-        run: docker rm -f iddaai-be || true
+      - name: Docker Build (AI Engine)
+        run: docker build -t iddaai-ai-engine:latest ./ai-engine

-      - name: Yeni Versiyonu Baslat
+      - name: Eski Konteynerleri Sil
+        run: |
+          docker rm -f iddaai-be || true
+          docker rm -f iddaai-ai-engine || true
+
+      - name: AI Engine'i Baslat
+        run: |
+          docker run -d \
+            --name iddaai-ai-engine \
+            --restart unless-stopped \
+            --network iddaai_iddaai-network \
+            -e DATABASE_URL='${{ secrets.DATABASE_URL }}' \
+            iddaai-ai-engine:latest
+
+      - name: Backend'i Baslat
        run: |
          docker run -d \
            --name iddaai-be \
@@ -25,11 +39,21 @@ jobs:
            --network iddaai_iddaai-network \
            -p 127.0.0.1:1810:3005 \
            -e NODE_ENV=production \
-            -e DATABASE_URL='postgresql://iddaai_user:IddaA1_S4crET!@iddaai-postgres:5432/iddaai_db?schema=public' \
-            -e REDIS_HOST='iddaai-redis' \
-            -e REDIS_PORT='6379' \
-            -e REDIS_PASSWORD='IddaA1_Redis_Pass!' \
+            -e DATABASE_URL='${{ secrets.DATABASE_URL }}' \
+            -e REDIS_HOST='${{ secrets.REDIS_HOST }}' \
+            -e REDIS_PORT='${{ secrets.REDIS_PORT }}' \
+            -e REDIS_PASSWORD='${{ secrets.REDIS_PASSWORD }}' \
            -e AI_ENGINE_URL='http://iddaai-ai-engine:8000' \
-            -e JWT_SECRET='b7V8jM2wP1L5mQxs2RdfFkAsLpI2oG!w' \
+            -e JWT_SECRET='${{ secrets.JWT_SECRET }}' \
            -e JWT_ACCESS_EXPIRATION='1d' \
            iddaai-be:latest /bin/sh -c "npx prisma migrate deploy && node dist/src/main.js"
+
+      - name: Saglik Kontrolu
+        run: |
+          sleep 10
+          echo "=== AI Engine logs ==="
+          docker logs --tail 30 iddaai-ai-engine || true
+          echo "=== Backend logs ==="
+          docker logs --tail 30 iddaai-be || true
+          echo "=== AI Engine health ==="
+          docker exec iddaai-ai-engine python -c "import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:8000/health').read().decode())" || echo "AI engine health check failed"
@@ -0,0 +1,57 @@
+# Node
+node_modules/
+dist/
+dist-*/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Environment
+.env
+.env.*
+!.env.example
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+venv/
+.venv/
+env/
+
+# Database / Docker Volumes
+/data/
+ai-engine/data/**/*.csv
+ai-engine/data/v26_shadow/
+ai-engine/data/__pycache__/
+postgres-data/
+redis-data/
+
+# OS / Editor
+.DS_Store
+.idea/
+.vscode/
+
+# Tests / Coverage
+coverage/
+
+# Logs
+logs/
+*.log
+
+# Uploads
+uploads/
+public/uploads/
+
+# Large Datasets and ML Models
+ai-engine/models/*
+!ai-engine/models/*.py
+!ai-engine/models/v25/
+!ai-engine/models/v27/
+!ai-engine/models/basketball_v25/
+!ai-engine/models/calibration/
+models/*
+!models/*.py
+colab_export/
+
@@ -0,0 +1,322 @@
+# AGENTS.md - Coding Agent Guidelines
+
+Bu dosya, bu repoda çalışan AI kodlama ajanları için rehberdir.
+
+---
+
+## 1. Build / Lint / Test Commands
+
+```bash
+# Development
+npm run start:dev          # Dev server with watch mode
+npm run build              # Production build (nest build)
+
+# Linting & Formatting
+npm run lint               # ESLint with Prettier
+npm run format             # Prettier write
+
+# Testing
+npm run test                      # Run all unit tests
+npm run test:watch                # Watch mode
+npm run test:e2e                  # End-to-end tests
+npx jest src/path/to/file.spec.ts # Run single test file
+npx jest --testNamePattern="test name" # Run specific test
+
+# Database
+npx prisma generate        # Generate Prisma client (required after install)
+npx prisma migrate dev     # Run migrations
+npx prisma db seed         # Seed database
+
+# Feeder Scripts
+npm run feeder:historical  # Historical data fetch
+npm run feeder:live        # Live match data fetch
+npm run feeder:basketball  # Basketball data fetch
+```
+
+---
+
+## 2. Code Style Guidelines
+
+### Imports (Sıralama)
+
+```typescript
+// 1. NestJS/common imports
+import { Controller, Get, Post, Body } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+
+// 2. External packages
+import { plainToInstance } from 'class-transformer';
+import * as bcrypt from 'bcrypt';
+
+// 3. Local imports (relative)
+import { UsersService } from './users.service';
+import { CreateUserDto } from './dto/user.dto';
+import { ApiResponse, createSuccessResponse } from '../../common/types';
+```
+
+### Formatting
+
+- **Single quotes** for strings
+- **Trailing commas** always
+- Prettier ile formatlama zorunlu
+- Dosya sonu boş satır
+
+### Types & Type Safety
+
+- `strictNullChecks: true` - null/undefined kontrolü zorunlu
+- `noImplicitAny: false` - any kullanımına izin var (Prisma dynamic access için)
+- Fonksiyon return type belirt: `async findOne(id: string): Promise<User>`
+- Interface > Type alias (objeler için)
+
+### Naming Conventions
+
+```typescript
+// Classes & Interfaces: PascalCase
+class UsersService {}
+interface ApiResponse<T> {}
+
+// Variables & Functions: camelCase
+const userService = new UsersService();
+async function findUserById() {}
+
+// Constants: UPPER_SNAKE_CASE
+const JWT_SECRET = 'secret';
+const IS_PUBLIC_KEY = 'isPublic';
+
+// Files: kebab-case
+user.dto.ts;
+users.service.ts;
+predictions.processor.spec.ts;
+
+// DTOs: Entity + Dto suffix
+(CreateUserDto, UpdateUserDto, UserResponseDto);
+```
+
+---
+
+## 3. DTO Pattern
+
+### Request DTOs
+
+```typescript
+export class CreateUserDto {
+  @ApiPropertyOptional({ example: 'user@example.com' })
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  @MinLength(8)
+  password: string;
+
+  @IsOptional()
+  @IsString()
+  firstName?: string;
+}
+```
+
+### Response DTOs (Security Critical)
+
+```typescript
+@Exclude()
+export class UserResponseDto {
+  @Expose()
+  id: string;
+
+  @Expose()
+  email: string;
+
+  // passwordHash intentionally NOT exposed
+}
+```
+
+### Controller Usage
+
+```typescript
+@Get('me')
+async getMe(@CurrentUser() user: User): Promise<ApiResponse<UserResponseDto>> {
+  const fullUser = await this.usersService.findOneWithDetails(user.id);
+  return createSuccessResponse(
+    plainToInstance(UserResponseDto, fullUser),
+  );
+}
+```
+
+**KRITIK:** Asla raw Prisma entity döndürme. Her zaman Response DTO kullan.
+
+---
+
+## 4. Architecture Patterns
+
+### Service Layer
+
+```typescript
+@Injectable()
+export class UsersService extends BaseService<
+  User,
+  CreateUserDto,
+  UpdateUserDto
+> {
+  constructor(prisma: PrismaService) {
+    super(prisma, 'User');
+  }
+
+  // Custom methods...
+}
+```
+
+### Controller Layer
+
+```typescript
+@ApiTags('Users')
+@ApiBearerAuth()
+@Controller('users')
+export class UsersController extends BaseController<
+  User,
+  CreateUserDto,
+  UpdateUserDto
+> {
+  constructor(private readonly usersService: UsersService) {
+    super(usersService, 'User');
+  }
+}
+```
+
+### API Response Format
+
+```typescript
+// All responses use this structure
+{
+  "success": true,
+  "status": 200,
+  "message": "Success",
+  "data": { ... },
+  "errors": []
+}
+
+// Helper functions
+createSuccessResponse(data, 'Message')
+createErrorResponse('Message', 400, ['error1'])
+createPaginatedResponse(items, total, page, limit)
+```
+
+---
+
+## 5. Error Handling
+
+### Throw NestJS HTTP Exceptions
+
+```typescript
+// Correct
+throw new NotFoundException('User not found');
+throw new ConflictException('EMAIL_ALREADY_EXISTS');
+throw new UnauthorizedException('INVALID_CREDENTIALS');
+
+// Wrong
+throw new Error('User not found'); // Don't use generic Error
+```
+
+### i18n Error Keys
+
+```typescript
+// Use translatable keys (check src/i18n/{lang}/errors.json)
+throw new ConflictException('EMAIL_ALREADY_EXISTS');
+// Translates to: "Email already exists" (en) / "Email zaten kayıtlı" (tr)
+```
+
+### Global Exception Filter
+
+- Tüm hatalar HTTP 200 ile döner (status body içinde)
+- `NODE_ENV=development` ise stack trace eklenir
+- Validation hataları otomatik formatlanır
+
+---
+
+## 6. Testing
+
+### Unit Test Structure
+
+```typescript
+import { Test, TestingModule } from '@nestjs/testing';
+
+describe('UsersService', () => {
+  let service: UsersService;
+  let prisma: PrismaService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        UsersService,
+        { provide: PrismaService, useValue: mockPrisma },
+      ],
+    }).compile();
+
+    service = module.get<UsersService>(UsersService);
+  });
+
+  it('should find user by id', async () => {
+    // Arrange
+    mockPrisma.user.findUnique.mockResolvedValue(mockUser);
+
+    // Act
+    const result = await service.findOne('id');
+
+    // Assert
+    expect(result).toEqual(mockUser);
+  });
+});
+```
+
+### Mocking External Dependencies
+
+```typescript
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockedAxios.post.mockResolvedValue({ data: { ok: true } });
+});
+```
+
+---
+
+## 7. Module Registration
+
+Redis-enabled modüller için `app.module.ts`:
+
+```typescript
+const redisEnabled = process.env.REDIS_ENABLED === 'true';
+
+@Module({
+  imports: [
+    ...(redisEnabled ? [QueueModule, PredictionsModule] : []),
+    // ...
+  ],
+})
+```
+
+---
+
+## 8. Environment Variables
+
+Zorunlu (`.env`):
+
+```env
+NODE_ENV=development
+PORT=3005
+DATABASE_URL=postgresql://postgres:password@localhost:15432/boilerplate_db
+JWT_SECRET=your-secret-key
+JWT_ACCESS_EXPIRATION=15m
+REDIS_ENABLED=false
+AI_ENGINE_URL=http://127.0.0.1:8000
+```
+
+---
+
+## 9. Pre-commit Checklist
+
+1. `npm run lint` - Lint errors fixed
+2. `npm run build` - Build succeeds
+3. `npm run test` - All tests pass
+4. Response DTOs used for all API responses
+5. No secrets/credentials in code
@@ -0,0 +1,273 @@
+# 🚀 Suggest-Bet-BE — Deployment Guide
+
+> **Tarih:** 2026-04-03
+> **Versiyon:** Sport Partition Release (Futbol/Basketbol Ayrımı)
+> **Amaç:** Masaüstü veya sunucuya kurulum adımları
+
+---
+
+## 🔑 Şifreler ve Bağlantı Bilgileri
+
+| Servis | Kullanıcı | Şifre | Host | Port |
+|--------|-----------|-------|------|------|
+| **PostgreSQL** | `suggestbet` | `SuGGesT2026SecuRe` | `localhost` | `15432` |
+| **Redis** | — | `RedisSecure2026` | `localhost` | `6379` |
+| **JWT Secret** | — | `9bfa42fbdc6031da6d7c0bd30e9f5b6378a071613d0c02acf95eb576249c3a25` | — | — |
+
+**Database URL:**
+```
+postgresql://suggestbet:SuGGesT2026SecuRe@localhost:15432/boilerplate_db?schema=public
+```
+
+---
+
+## 📋 Gereksinimler
+
+- **Node.js:** v20.19+
+- **Docker + Docker Compose:** PostgreSQL + Redis için
+- **npm:** Paket yöneticisi
+
+---
+
+## 🔧 Adım Adım Kurulum
+
+### Adım 1: Kodu Çek
+
+```bash
+cd ~/Documents/Suggest-Bet-BE
+git pull origin main
+```
+
+### Adım 2: .env Dosyasını Oluştur
+
+```bash
+# /Users/piton/Documents/Suggest-Bet-BE/.env
+NODE_ENV=development
+PORT=3005
+DATABASE_URL="postgresql://suggestbet:SuGGesT2026SecuRe@localhost:15432/boilerplate_db?schema=public"
+JWT_SECRET=9bfa42fbdc6031da6d7c0bd30e9f5b6378a071613d0c02acf95eb576249c3a25
+JWT_ACCESS_EXPIRATION=7d
+JWT_REFRESH_EXPIRATION=7d
+REDIS_ENABLED=true
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=RedisSecure2026
+DEFAULT_LANGUAGE=en
+FALLBACK_LANGUAGE=en
+ENABLE_MAIL=false
+ENABLE_S3=false
+ENABLE_WEBSOCKET=false
+ENABLE_MULTI_TENANCY=false
+THROTTLE_TTL=60000
+THROTTLE_LIMIT=100
+ENABLE_GEMINI=true
+GOOGLE_API_KEY=your-google-api-key
+GEMINI_MODEL=gemini-2.5-flash
+AI_ENGINE_URL=http://127.0.0.1:8000
+```
+
+### Adım 3: Docker Infrastructure Başlat
+
+```bash
+cd ~/Documents/Suggest-Bet-BE
+docker compose up -d postgres redis
+```
+
+PostgreSQL'in hazır olduğunu kontrol et:
+```bash
+docker exec -i suggestbet-postgres pg_isready -U suggestbet
+# Çıktı: /var/run/postgresql:5432 - accepting connections
+```
+
+### Adım 4: Dump'u Restore Et
+
+```bash
+# Dump dosyasını container'a kopyala
+docker cp /path/to/dump-boilerplate_db-202604020914-v5 suggestbet-postgres:/tmp/dump_file
+
+# Restore et
+export PGPASSWORD="SuGGesT2026SecuRe"
+docker exec -e PGPASSWORD="$PGPASSWORD" suggestbet-postgres pg_restore \
+  -U suggestbet -d boilerplate_db --clean --if-exists /tmp/dump_file
+```
+
+### Adım 5: Sport Partition Migration'ını Çalıştır
+
+**Sırayla çalıştır — her biri ayrı transaction:**
+
+```bash
+export PGPASSWORD="SuGGesT2026SecuRe"
+DB="suggestbet-postgres"
+MIGRATION_DIR="prisma/migrations/20260403161000_sport_partition"
+
+# 1. Yeni team stats tabloları oluştur
+docker exec -e PGPASSWORD="$PGPASSWORD" -i $DB psql -U suggestbet -d boilerplate_db < $MIGRATION_DIR/01_create_team_stats.sql
+
+# 2. Team stats verilerini kopyala
+docker exec -e PGPASSWORD="$PGPASSWORD" -i $DB psql -U suggestbet -d boilerplate_db < $MIGRATION_DIR/02_copy_team_stats.sql
+
+# 3. Yeni AI features tabloları oluştur
+docker exec -e PGPASSWORD="$PGPASSWORD" -i $DB psql -U suggestbet -d boilerplate_db < $MIGRATION_DIR/03_create_ai_features.sql
+
+# 4. AI features verilerini kopyala
+docker exec -e PGPASSWORD="$PGPASSWORD" -i $DB psql -U suggestbet -d boilerplate_db < $MIGRATION_DIR/04_copy_ai_features.sql
+
+# 5. match_player_stats → basketball_player_stats rename
+docker exec -e PGPASSWORD="$PGPASSWORD" -i $DB psql -U suggestbet -d boilerplate_db < $MIGRATION_DIR/05_rename_player_stats.sql
+
+# 6. odd_categories + odd_selections'e sport kolonu ekle
+docker exec -e PGPASSWORD="$PGPASSWORD" -i $DB psql -U suggestbet -d boilerplate_db < $MIGRATION_DIR/06_add_sport_to_odds.sql
+```
+
+**odd_selections için batch update (14.8M satır — her çalıştır 1M günceller):**
+
+```bash
+# Bunu "remaining = 0" olana kadar tekrar tekrar çalıştır
+export PGPASSWORD="SuGGesT2026SecuRe"
+docker exec -e PGPASSWORD="$PGPASSWORD" -i suggestbet-postgres psql -U suggestbet -d boilerplate_db -c "
+WITH t AS (
+  SELECT os.db_id, oc.sport 
+  FROM odd_selections os 
+  JOIN odd_categories oc ON os.odd_category_db_id = oc.db_id 
+  WHERE os.sport IS NULL 
+  LIMIT 1000000
+)
+UPDATE odd_selections SET sport = t.sport FROM t WHERE odd_selections.db_id = t.db_id;
+
+SELECT COUNT(*) as remaining FROM odd_selections WHERE sport IS NULL;
+"
+```
+
+**Kalan satırlar bitince index oluştur:**
+```bash
+export PGPASSWORD="SuGGesT2026SecuRe"
+docker exec -e PGPASSWORD="$PGPASSWORD" -i suggestbet-postgres psql -U suggestbet -d boilerplate_db -c "
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_odd_selections_sport ON odd_selections(sport) WHERE sport IS NOT NULL;
+"
+```
+
+### Adım 6: Bağımlılıkları Yükle + Prisma Generate
+
+```bash
+cd ~/Documents/Suggest-Bet-BE
+
+# Bağımlılıkları yükle
+npm ci
+
+# Prisma client oluştur
+npx prisma generate
+```
+
+### Adım 7: Build + Başlat
+
+```bash
+# Build
+npm run build
+
+# Başlat
+npm run start:prod
+```
+
+### Adım 8: Doğrulama
+
+```bash
+# Sağlık kontrolü
+curl http://localhost:3005/api/health
+
+# Swagger UI
+open http://localhost:3005/api/docs
+
+# Yeni tabloları kontrol et
+export PGPASSWORD="SuGGesT2026SecuRe"
+docker exec -e PGPASSWORD="$PGPASSWORD" -i suggestbet-postgres psql -U suggestbet -d boilerplate_db -c "
+SELECT 'football_team_stats' as tbl, COUNT(*) FROM football_team_stats
+UNION ALL SELECT 'basketball_team_stats', COUNT(*) FROM basketball_team_stats
+UNION ALL SELECT 'basketball_player_stats', COUNT(*) FROM basketball_player_stats
+UNION ALL SELECT 'odd_categories (sport)', COUNT(*) FROM odd_categories WHERE sport IS NOT NULL
+UNION ALL SELECT 'odd_selections (sport)', COUNT(*) FROM odd_selections WHERE sport IS NOT NULL;
+"
+```
+
+---
+
+## 🤖 AI Engine (Opsiyonel)
+
+```bash
+cd ~/Documents/Suggest-Bet-BE/ai-engine
+
+# Bağımlılıklar
+pip install -r requirements.txt
+
+# Başlat
+uvicorn main:app --host 0.0.0.0 --port 8000
+```
+
+---
+
+## ✅ Tablo Durumu (Migration Sonrası)
+
+| Tablo | Satır (~) | Durum |
+|-------|-----------|-------|
+| `football_team_stats` | 217,956 | ✅ Yeni |
+| `basketball_team_stats` | 48,824 | ✅ Yeni |
+| `basketball_player_stats` | 273,140 | ✅ Rename edildi |
+| `football_ai_features` | 0 | ⚠️ Feeder dolduracak |
+| `basketball_ai_features` | 0 | ⚠️ Feeder dolduracak |
+| `odd_categories (sport)` | 2,695,511 | ✅ Güncellendi |
+| `odd_selections (sport)` | 14,810,396 | ✅ Güncellendi |
+| `match_team_stats` (ESKİ) | 266,780 | 🗑️ Silinebilir (yedek olarak kalsın) |
+| `match_ai_features` (ESKİ) | 0 | 🗑️ Silinebilir |
+
+---
+
+## 🗑️ Eski Tabloları Silme (Opsiyonel)
+
+**SADECE her şey çalıştığını doğruladıktan sonra:**
+
+```bash
+export PGPASSWORD="SuGGesT2026SecuRe"
+docker exec -e PGPASSWORD="$PGPASSWORD" -i suggestbet-postgres psql -U suggestbet -d boilerplate_db -c "
+DROP TABLE IF EXISTS match_team_stats CASCADE;
+DROP TABLE IF EXISTS match_ai_features CASCADE;
+"
+```
+
+---
+
+## 🔧 Sorun Giderme
+
+### PostgreSQL başlamıyor (postmaster.pid hatası)
+```bash
+docker compose stop postgres
+docker compose rm -f postgres
+docker volume rm suggest-bet-be_pgml_data
+docker compose up -d postgres
+# Sonra dump + migration tekrar
+```
+
+### Docker Desktop başlamıyor (disk dolu)
+```bash
+# Büyük dosyaları temizle
+rm -rf ~/Library/Caches/Homebrew/*
+rm -rf ~/.npm/_cacache
+docker system prune -af
+df -h /  # En az 3-4GB boş olmalı
+```
+
+### Feeder çalışmıyor
+```bash
+# Logları kontrol et
+tail -f logs/app.log  # veya docker logs suggestbet-app
+
+# Manuel feeder çalıştır
+npm run feeder:live
+```
+
+---
+
+## 📝 Notlar
+
+- **Veri kaybolmaz** — eski tablolar migration sonrası silinmez, yedek olarak kalır
+- **Feeder** otomatik yeni tablolara yazar (`footballTeamStats`, `basketballTeamStats`, vb.)
+- **Redis** opsiyonel — `REDIS_ENABLED=false` yapabilirsin (in-memory fallback)
+- **Swagger** sadece development modunda aktif
@@ -16,7 +16,7 @@ RUN npm ci
 COPY . .

 # Generate Prisma client
-RUN npx prisma generate
+RUN DATABASE_URL="postgresql://dummy:dummy@localhost/dummy" npx prisma generate

 # Build the application
 RUN npm run build
@@ -38,7 +38,7 @@ RUN apk add --no-cache --virtual .build-deps python3 make g++ cairo-dev pango-de

 # Copy Prisma schema and generate client
 COPY prisma ./prisma
-RUN npx prisma generate
+RUN DATABASE_URL="postgresql://dummy:dummy@localhost/dummy" npx prisma generate

 # Copy built application
 COPY --from=builder /app/dist ./dist
@@ -47,7 +47,7 @@ COPY --from=builder /app/dist ./dist
 COPY --from=builder /app/src/i18n ./dist/i18n

 # Copy league filter config files (critical: without these, feeder stores ALL matches)
-COPY top_leagues.json basketball_top_leagues.json ./
+COPY qualified_leagues.json top_leagues.json basketball_top_leagues.json ./

 # Set environment
 ENV NODE_ENV=production
@@ -0,0 +1,517 @@
+# Suggest-Bet-BE — AI Agent Context
+
+> **Last Updated:** 2026-04-06
+> **Purpose:** Comprehensive project reference for AI agents working on this codebase.
+
+---
+
+## 1. Project Overview
+
+**Suggest-Bet-BE** is an **AI-powered sports betting prediction platform** backend. It provides:
+
+- AI-driven predictions for football & basketball matches
+- Smart coupon generation (SAFE, BALANCED, AGGRESSIVE, VALUE, MIRACLE strategies)
+- Live score tracking & odds monitoring
+- Web scraping from Mackolik.com for historical & live match data
+- Google Gemini AI for natural language match commentary
+- User coupon tracking (ROI, Win Rate analytics)
+
+### Technology Stack
+
+| Layer       | Technology                                   |
+| ----------- | -------------------------------------------- |
+| Backend API | NestJS 11 (TypeScript)                       |
+| AI Engine   | Python FastAPI (v20+)                        |
+| Database    | PostgreSQL 16 + Prisma ORM                   |
+| Queue       | BullMQ + Redis (optional)                    |
+| Cache       | Redis or in-memory fallback                  |
+| Auth        | JWT + Passport (Access 15min + Refresh 7day) |
+| Scraping    | Axios + Cheerio (Mackolik HTML parsing)      |
+| Logging     | Pino (structured logging)                    |
+| i18n        | nestjs-i18n (TR, EN)                         |
+| API Docs    | Swagger                                      |
+| Deploy      | Docker Compose                               |
+
+---
+
+## 2. Architecture
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                        CLIENTS (Web/Mobile)                       │
+└───────────────────────────────┬──────────────────────────────────┘
+                                │ HTTP/REST
+┌───────────────────────────────▼──────────────────────────────────┐
+│                    NestJS Backend (Port 3005)                      │
+│  ┌─────────┬──────────┬──────────┬──────────┬─────────────────┐  │
+│  │  Auth   │  Admin   │ Matches  │ Leagues  │  Predictions    │  │
+│  │ Module  │ Module   │  Module  │  Module  │   Module        │  │
+│  ├─────────┼──────────┼──────────┼──────────┼─────────────────┤  │
+│  │ Coupons │ Analysis │  Gemini  │ Social-  │    Health       │  │
+│  │ Module  │  Module  │  Module  │ Poster   │   Module        │  │
+│  │SporToto │  Feeder  │  Users   │          │                 │  │
+│  └─────────┴──────────┴──────────┴──────────┴─────────────────┘  │
+│  ┌──────────────────────────────────────────────────────────────┐ │
+│  │  Services: AiService | MatchAnalysis | Scraper              │ │
+│  ├──────────────────────────────────────────────────────────────┤ │
+│  │  Tasks: DataFetcher (Cron) | LiveUpdater | LimitResetter    │ │
+│  └──────────────────────────────────────────────────────────────┘ │
+────┬─────────────────┬────────────────────┬──────────────────────┘
+     │                 │                    │
+     ▼                 ▼                    ▼
+┌─────────┐    ┌──────────────┐    ┌──────────────────┐
+│PostgreSQL│    │ Redis/BullMQ │    │ AI Engine (py)   │
+│  (3.6GB) │    │  (Optional)  │    │ FastAPI:8000     │
+└─────────    └──────────────    └──────────────────
+                                           │
+                                   ───────▼───────┐
+                                   │ Mackolik API   │
+                                   │ (Data Source)  │
+                                   └───────────────┘
+```
+
+### Database Statistics (~)
+
+- `matches`: 237K permanent match records
+- `live_matches`: ~82 active/upcoming matches (daily cycle)
+- `match_player_participation`: 3.3M
+- `odd_selections`: 8.5M
+- `teams`: 19,595 | `players`: 217K | `leagues`: 1,505
+
+---
+
+## 3. Directory Structure
+
+```
+src/
+├── app.module.ts           # Root module (Redis, Config, i18n, guards)
+├── main.ts                 # Entry point, Swagger, Helmet, ValidationPipe
+├── common/                 # Shared layer
+│   ├── base/               # Generic BaseService<T> & BaseController<T>
+│   ├── types/              # ApiResponse<T>, pagination DTOs
+│   ├── filters/            # GlobalExceptionFilter (HTTP 200 wrapper)
+│   ├── interceptors/       # ResponseInterceptor, SanitizeInterceptor
+│   ├── decorators/         # @Public(), @Roles(), @CurrentUser()
+│   └── queues/             # BullMQ queue module
+├── config/                 # Env validation (Zod), config factories
+├── database/               # PrismaService
+├── i18n/                   # TR/EN translations (common, errors, validation, auth)
+├── modules/                # 13 feature modules
+│   ├── admin/              # Superadmin panel (user mgmt, settings, analytics)
+│   ├── analysis/           # Multi-match analysis orchestration
+│   ├── auth/               # JWT auth, refresh tokens, guards
+│   ├── coupons/            # SmartCouponService (5 strategies), UserCouponService
+│   ├── feeder/             # Historical data scraping (Mackolik)
+│   ├── gemini/             # Google Gemini AI integration
+│   ├── health/             # Liveness, readiness, AI Engine health
+│   ├── leagues/            # Country/league/team discovery, H2H
+│   ├── matches/            # Match listing, details, active leagues
+│   ├── predictions/        # AI predictions with BullMQ queue & 6h cache
+│   ├── social-poster/      # Twitter API v2, Canvas image generation
+│   ├── spor-toto/          # Spor Toto integration
+│   └── users/              # User CRUD (BaseController pattern)
+├── scripts/                # Feeder runners, cleanup scripts
+├── services/               # Shared services
+│   ├── ai.service.ts       # Python AI Engine bridge
+│   ├── match-analysis.service.ts  # 7-phase analysis orchestrator
+│   └── scraper.service.ts  # Mackolik HTML scraping
+└── tasks/                  # Cron jobs (15min, 30min, daily)
+    ├── data-fetcher.task.ts      # Live matches, odds fetching
+    ├── live-updater.task.ts      # Score updates, match finalization
+    └── limit-resetter.task.ts    # Usage limits, subscription expiry
+
+ai-engine/                # Python FastAPI ML engine
+├── main.py               # FastAPI app, routes
+├── services/             # single_match_orchestrator.py
+├── core/                 # Core algorithms
+├── features/             # Feature engineering
+├── models/               # ML models
+├── training/             # Model training scripts
+├── config/               # Configuration
+├── utils/                # Utility functions
+└── tests/                # Test files
+```
+
+---
+
+## 4. Key Modules
+
+### Auth Module
+
+- Register, Login, Refresh, Logout endpoints
+- bcrypt (12 rounds), JWT Access (15min) + Refresh Token (7 days, DB-stored)
+- Global guards: `JwtAuthGuard`, `RolesGuard`, `PermissionsGuard`
+
+### Predictions Module
+
+- Requires Redis (`REDIS_ENABLED=true`), conditionally loaded
+- BullMQ queue with worker processor
+- 6-hour TTL cache on prediction results
+- AI Engine call: `POST /v20plus/analyze/{matchId}`
+
+### Coupons Module
+
+- `SmartCouponService`: 5 strategies (SAFE ≥78% confidence/2 matches, BALANCED, AGGRESSIVE, VALUE EV+, MIRACLE)
+- `UserCouponService`: Coupon creation, bet settlement (MS 1/X/2, Alt/Üst, KG Var/Yok)
+
+### Feeder Module
+
+- Historical scraping from 2023-06-01 to present (reverse chronological)
+- Concurrency=20, 300ms delay, 50 max retry, 502 exponential backoff
+- Resume support with state management
+
+### Analysis Module
+
+- Usage limits: Free (10 analyses/3 coupons/day) vs Premium (50 analyses/10 coupons)
+- 7-phase flow: URL Parse → Scrape → Python Engine → Strategy → Similar Matches → Final Prediction → DB Save
+
+### Social Poster Module
+
+- Twitter API v2 integration
+- Canvas-based prediction card image generation
+- Gemini-powered Turkish caption generation
+
+---
+
+## 5. Scheduled Tasks (Cron)
+
+| Task                        | Schedule       | Description                                              |
+| --------------------------- | -------------- | -------------------------------------------------------- |
+| `fetchLiveMatches()`        | `*/15 * * * *` | Fetch football matches from Mackolik API                 |
+| `fetchOddsForPreMatches()`  | `*/15 * * * *` | Fetch odds for upcoming matches (football + basketball)  |
+| `fetchBasketballMatches()`  | Manual         | Basketball data via `basketball_top_leagues.json` filter |
+| `updateLiveScores()`        | `*/15 * * * *` | Update live match scores                                 |
+| `finalizeFinishedMatches()` | `*/30 * * * *` | Migrate finished: live_matches → matches table           |
+| `resetUsageLimits()`        | `0 3 * * *`    | Reset daily usage limits (03:00 Istanbul time)           |
+| `cleanupOldData()`          | `0 4 * * *`    | Delete 30-day old AI logs, 1-day finished live_matches   |
+| `checkSubscriptions()`      | `0 0 * * *`    | Mark expired subscriptions                               |
+
+---
+
+## 6. AI Engine (Python FastAPI)
+
+Independent microservice on port 8000.
+
+### Endpoints
+
+| Method | Path                               | Description                     |
+| ------ | ---------------------------------- | ------------------------------- |
+| POST   | `/v20plus/analyze/{match_id}`      | Single match analysis (main)    |
+| GET    | `/v20plus/analyze-htms/{match_id}` | First half - Full time analysis |
+| GET    | `/v20plus/analyze-htft/{match_id}` | HT/FT probabilities             |
+| POST   | `/v20plus/coupon`                  | Smart coupon generation         |
+| GET    | `/v20plus/daily-banker`            | Daily banker picks              |
+| GET    | `/v20plus/reversal-watchlist`      | Score reversal watchlist        |
+| GET    | `/health`                          | Health check                    |
+
+### Output Structure (`SingleMatchPredictionPackage`)
+
+```typescript
+{
+  model_version: "v20plus.X",
+  match_info: { match_id, match_name, home_team, away_team, league, match_date_ms },
+  data_quality: { label: "HIGH"|"MEDIUM"|"LOW", score, flags, lineup_counts },
+  risk: { level: "LOW"|"MEDIUM"|"HIGH"|"EXTREME", score, is_surprise_risk, warnings },
+  main_pick: { market, pick, probability, confidence, odds, bet_grade, edge },
+  value_pick: { ... },
+  bet_advice: { playable, suggested_stake_units, reason },
+  bet_summary: [{ market, pick, raw_confidence, calibrated_confidence, bet_grade }],
+  supporting_picks: [...],
+  aggressive_pick: { market, pick, probability, confidence, odds },
+  scenario_top5: [{ score, prob }],
+  score_prediction: { ft, ht, xg_home, xg_away, xg_total },
+  market_board: { ... },
+  reasoning_factors: string[],
+  ai_commentary: string  // Turkish commentary from Gemini
+}
+```
+
+---
+
+## 7. API Response Format
+
+All responses follow this standard structure:
+
+```json
+{
+  "success": true,
+  "status": 200,
+  "message": "İşlem başarıyla tamamlandı",  // i18n translated
+  "data": { ... },
+  "errors": []
+}
+```
+
+**Critical Rule:** Controllers must NEVER return raw Prisma entities. Always use Response DTOs with `@Exclude()` and `@Expose()` from `class-transformer`.
+
+---
+
+## 8. Configuration
+
+### Environment Variables
+
+```env
+NODE_ENV=development
+PORT=3005
+DATABASE_URL=postgresql://user:password@localhost:15432/boilerplate_db
+JWT_SECRET=your-secret-key
+JWT_ACCESS_EXPIRATION=15m
+JWT_REFRESH_EXPIRATION=7d
+REDIS_ENABLED=false
+REDIS_HOST=localhost
+REDIS_PORT=6379
+AI_ENGINE_URL=http://127.0.0.1:8000
+ENABLE_GEMINI=false
+GOOGLE_API_KEY=your-api-key
+```
+
+### Config Files
+
+- `top_leagues.json` — Football top league IDs (live match filter)
+- `basketball_top_leagues.json` — Basketball top league IDs
+- `bet-type.json` — Bet type definitions
+
+---
+
+## 9. Build & Run Commands
+
+```bash
+# Development
+npm run start:dev              # Watch mode (port 3005)
+
+# Production
+npm run build && npm run start:prod
+
+# Feeder (Data Collection)
+npm run feeder:historical      # Historical scraping (2023-06→present)
+npm run feeder:fill-gaps       # Fill missing data
+npm run feeder:basketball      # Basketball data
+npm run feeder:live            # Live data
+
+# Database
+npx prisma generate            # Regenerate Prisma client
+npx prisma migrate dev         # Run migrations
+npx prisma db seed             # Seed database
+
+# Testing
+npm run test                   # Unit tests
+npm run test:e2e               # E2E tests
+npx jest src/path/to/file.spec.ts  # Single test file
+
+# Lint/Format
+npm run lint                   # ESLint with Prettier
+npm run format                 # Prettier write
+
+# Docker
+docker-compose up -d postgres redis   # Infrastructure
+docker-compose up -d                 # All services
+
+# AI Engine (Python)
+cd ai-engine && uvicorn main:app --host 0.0.0.0 --port 8000 --reload
+
+# Utility
+npm run swagger:summary        # Export endpoint summary
+npm run cleanup:live           # Cleanup live matches
+```
+
+---
+
+## 10. Code Style Guidelines
+
+### Imports Order
+
+```typescript
+// 1. NestJS/common imports
+import { Controller, Get, Post, Body } from '@nestjs/common';
+
+// 2. External packages
+import * as bcrypt from 'bcrypt';
+
+// 3. Local imports (relative)
+import { UsersService } from './users.service';
+```
+
+### Naming Conventions
+
+- Classes/Interfaces: `PascalCase`
+- Variables/Functions: `camelCase`
+- Constants: `UPPER_SNAKE_CASE`
+- Files: `kebab-case`
+- DTOs: `Entity + Dto` suffix (CreateUserDto, UpdateUserDto)
+
+### Types
+
+- `strictNullChecks: true` — null/undefined checks required
+- `noImplicitAny: false` — `any` allowed (Prisma dynamic access)
+- Specify function return types: `async findOne(id: string): Promise<User>`
+
+### Error Handling
+
+```typescript
+// Use NestJS HTTP Exceptions with i18n keys
+throw new NotFoundException('USER_NOT_FOUND');
+throw new ConflictException('EMAIL_ALREADY_EXISTS');
+
+// Reference src/i18n/{lang}/errors.json for available keys
+```
+
+---
+
+## 11. Known Issues & Gotchas
+
+1. **Predictions module** requires Redis. Disabled when `REDIS_ENABLED=false`.
+2. **Gemini AI** is optional. Returns `null` commentary when disabled.
+3. **Global Exception Filter** wraps all errors as HTTP 200 (status in body).
+4. **Lineup scraping** is disabled — only Team Stats are used (V20 optimization).
+5. **Feeder V17 AI feature calculation** is disabled — V20 model runs in Python.
+6. **BigInt serialization**: `BigInt.prototype.toJSON = function() { return this.toString(); }` polyfill in main.ts.
+7. **i18n assets** copied via `nest-cli.json` `"assets": ["i18n/**/*"]` config.
+
+---
+
+## 12. Reference Files for AI Agents
+
+When working on this project, consult:
+
+- `project_summary.md` — Comprehensive project documentation (Turkish)
+- `README.md` — Architecture decisions, quick start guide
+- `prompt.md` — AI assistant reference guide with agent roles
+- `AGENTS.md` — Coding guidelines, DTO patterns, test structure
+- `.agent/` — Skills and agent role definitions
+- `top_leagues.json` / `basketball_top_leagues.json` — League filters
+
+---
+
+## 13. Team Logos
+
+Team logo URL template: `https://file.mackolikfeeds.com/teams/{teamId}`
+
+---
+
+## 14. 🆕 VQWEN Model Integration (Since 2026-04-06)
+
+We have integrated a new high-performance prediction engine called **VQWEN v3**.
+
+### VQWEN Model Features
+- **Accuracy:** +244.4 Units profit in Time-Series Backtest (75.1% Win Rate on BTTS/Over markets).
+- **Features Used:** 
+    - `ELO Ratings` (Real-time team strength).
+    - `Contextual Goals` (Home/Away specific performance).
+    - `Rest Days` (Fatigue factor for teams playing < 3 days).
+    - `H2H Win Rate` (Historical dominance).
+    - `Form Points` (Last 5 games streak).
+    - `Squad Strength` (Based on starting XI participation).
+- **Files:**
+    - `ai-engine/scripts/train_vqwen_v3.py` — Training script.
+    - `ai-engine/services/single_match_orchestrator.py` — Integration point.
+    - `ai-engine/models/vqwen/` — Pickle models (`vqwen_ms.pkl`, etc.).
+
+### New Live Lineup/Sidelined Fetcher
+- **Problem:** `lineups` and `sidelined` columns in `live_matches` were empty.
+- **Fix:** Added `updateLineupsAndSidelined()` method to `src/tasks/data-fetcher.task.ts`.
+- **Mechanism:** Uses `FeederScraperService.fetchStartingFormation` directly via Cron (`*/15 * * * *`).
+- **Status:** Active.
+
+### Database Schema Updates
+- **`substate` Column:** Added to `matches` table to track specific match states (e.g., "penalties", "overtime", "postponed").
+- **Sport Partition:** Tables are now partitioned by sport (`football_team_stats` vs `basketball_team_stats`).
+
+---
+
+## 16. 🔍 HT/FT Reversal Analysis (Since 2026-04-07)
+
+### HT/FT Reversal (1/2 & 2/1) Pattern Detection
+
+Reversal matches (İY/MS = 1/2 or 2/1) are statistically rare events that can indicate match-fixing or unusual patterns.
+
+#### Key Findings (147,248 matches analyzed)
+
+| Metric | Value |
+|--------|-------|
+| **Total Reversal Matches** | 13,112 (8.90%) |
+| **1/2 (Home leads HT, Away wins FT)** | 5,992 (4.07%) |
+| **2/1 (Away leads HT, Home wins FT)** | 7,120 (4.84%) |
+
+#### 🚨 Basketball Leagues Have Suspiciously High Reversal Rates
+
+| League | Reversals | Total | Rate |
+|--------|-----------|-------|------|
+| Eurobasket U20 | 36 | 120 | **30.00%** 🔴 |
+| EuroLeague 🏀 | 183 | 639 | **28.64%** 🔴 |
+| PBA Commissioners 🏀 | 54 | 189 | **28.57%** 🔴 |
+| Ulusal Süper Lig 🏀 | 148 | 547 | **27.06%** 🔴 |
+| NBA 🏀 | 656 | 2,696 | **24.33%** 🔴 |
+
+**All top 15 leagues by reversal rate are BASKETBALL.** Football leagues show normal rates (5-8%).
+
+#### Suspicious Patterns
+
+1. **Comeback Magnitude:**
+   - 1 goal/point: 36.1% (normal)
+   - 2 goals/points: 13.1% (suspicious)
+   - **3+ goals/points: 50.8%** 🔴 **EXTREMELY HIGH**
+
+2. **Extreme Comebacks (Basketball):**
+   - Mineros vs Irapuato: HT 39-45 → FT 102-61 (41 point swing!)
+   - Utah vs Memphis: HT 65-64 → FT 103-140 (37 point swing!)
+   - These are statistically near-impossible without manipulation
+
+3. **Favorite Loss Rate:**
+   - 42.7% of reversals had the pre-match favorite lose (should be ~25-30%)
+
+#### Impact on Model
+
+- HT/FT model accuracy: **20.3%** (low due to reversal noise)
+- Basketball reversal data creates **training noise**
+- **Recommendation:** Either exclude basketball from HT/FT training or train separate basketball-specific model
+
+#### HT/FT Model Files
+
+- **Training script:** `ai-engine/scripts/train_htft_vqwen.py`
+- **Model output:** `ai-engine/models/xgboost/xgb_ht_ft.json` + `.pkl`
+- **Features:** 27 (Odds + HT/FT Tendencies + League stats)
+- **Status:** Working, outputs 9-class probabilities in `market_board.HTFT.probs`
+
+---
+
+## 17. 🐛 Lineup Parsing Fix (Since 2026-04-07)
+
+### Problem
+AI Engine reported `"lineup_unavailable"` and `"lineup_incomplete"` flags even when `live_matches.lineups` contained full 11/11 lineup data from Mackolik.
+
+### Root Cause
+Mackolik stores lineups in `"stats"` key format:
+```json
+{
+  "stats": {
+    "home": [{ "personId": "...", "position": "...", ... }, ...],
+    "away": [{ "personId": "...", "position": "...", ... }, ...]
+  }
+}
+```
+
+But the parser expected `"xi"`, `"starting"`, or `"lineup"` keys at root level.
+
+### Fix
+Updated `_parse_lineups_json()` in `ai-engine/services/single_match_orchestrator.py`:
+- Added fallback to check `lineups_json.get("stats")` for home/away arrays
+- Now correctly parses Mackolik's nested format
+- Result: `home_lineup_count: 11`, `away_lineup_count: 11`, `lineup_source: "confirmed_live"`
+
+---
+
+## 18. Docker Deployment
+
+```yaml
+# docker-compose.yml services:
+services:
+  app: # NestJS (port 3000→3000)
+  postgres: # PostgreSQL 17 Alpine (port 15432:5432)
+  redis: # Redis 7 Alpine (port 6379)
+  adminer: # Database UI (dev profile, port 8080)
+  ai-engine: # Python FastAPI (port 8002:8000)
+```
+
+---
+
+_This file is maintained for AI agent context. Update when architecture or conventions change._
@@ -0,0 +1,337 @@
+# 🚀 Enterprise NestJS Boilerplate (Antigravity Edition)
+
+[![NestJS](https://img.shields.io/badge/NestJS-E0234E?style=for-the-badge&logo=nestjs&logoColor=white)](https://nestjs.com/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?style=for-the-badge&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![Prisma](https://img.shields.io/badge/Prisma-2D3748?style=for-the-badge&logo=prisma&logoColor=white)](https://www.prisma.io/)
+[![PostgreSQL](https://img.shields.io/badge/PostgreSQL-4169E1?style=for-the-badge&logo=postgresql&logoColor=white)](https://www.postgresql.org/)
+[![Docker](https://img.shields.io/badge/Docker-2496ED?style=for-the-badge&logo=docker&logoColor=white)](https://www.docker.com/)
+
+> **FOR AI AGENTS & DEVELOPERS:** This documentation is structured to provide deep context, architectural decisions, and operational details to ensure seamless handover to any AI coding assistant (like Antigravity) or human developer.
+
+---
+
+## 🧠 Project Context & Architecture (Read Me First)
+
+This is an **opinionated, production-ready** backend boilerplate built with NestJS. It is designed to be scalable, type-safe, and fully localized.
+
+### 🏗️ Core Philosophy
+
+- **Type Safety First:** Strict TypeScript configuration. `any` is forbidden. DTOs are the source of truth.
+- **Generic Abstraction:** `BaseService` and `BaseController` handle 80% of CRUD operations, allowing developers to focus on business logic.
+- **i18nNative:** Localization is not an afterthought. It is baked into the exception filters, response interceptors, and guards.
+- **Security by Default:** JWT Auth, RBAC (Role-Based Access Control), Throttling, and Helmet are pre-configured.
+
+### 📐 Architectural Decision Records (ADR)
+
+_To understand WHY things are the way they are:_
+
+1.  **Handling i18n Assets:**
+    - **Problem:** Translation JSON files are not TypeScript code, so `tsc` ignores them during build.
+    - **Solution:** We configured `nest-cli.json` with `"assets": ["i18n/**/*"]`. This ensures `src/i18n` is copied to `dist/i18n` automatically.
+    - **Note:** When running with `node`, ensure `dist/main.js` can find these files.
+
+2.  **Global Response Wrapping:**
+    - **Mechanism:** `ResponseInterceptor` wraps all successful responses.
+    - **Feature:** It automatically translates the "Operation successful" message based on the `Accept-Language` header using `I18nService`.
+    - **Output Format:**
+      ```json
+      {
+        "success": true,
+        "status": 200,
+        "message": "İşlem başarıyla tamamlandı", // Translated
+        "data": { ... }
+      }
+      ```
+
+3.  **Centralized Error Handling:**
+    - **Mechanism:** `GlobalExceptionFilter` catches all `HttpException` and unknown `Error` types.
+    - **Feature:** It accepts error keys (e.g., `AUTH_REQUIRED`) and translates them using `i18n`. If a translation is found in `errors.json`, it is returned; otherwise, the original message is shown.
+
+4.  **UUID Generation:**
+    - **Decision:** We use Node.js native `crypto.randomUUID()` instead of the external `uuid` package to avoid CommonJS/ESM compatibility issues.
+
+---
+
+## 🚀 Quick Start for AI & Humans
+
+### 1. Prerequisites
+
+- **Node.js:** v20.19+ (LTS)
+- **Docker:** For running PostgreSQL and Redis effortlessly.
+- **Package Manager:** `npm` (Lockfile: `package-lock.json`)
+
+### 2. Environment Setup
+
+```bash
+cp .env.example .env
+# ⚠️ CRITICAL: Ensure DATABASE_URL includes the username!
+# Example: postgresql://postgres:password@localhost:15432/boilerplate_db
+# Required for v20 prediction flow:
+# AI_ENGINE_URL=http://127.0.0.1:8000
+```
+
+### 3. Installation & Database
+
+```bash
+# Install dependencies
+npm ci
+
+# Start Infrastructure (Postgres + Redis)
+docker-compose up -d postgres redis
+
+# Generate Prisma Client (REQUIRED after install)
+npx prisma generate
+
+# Run Migrations
+npx prisma migrate dev
+
+# Seed Database (Optional - Creates Admin & Roles)
+npx prisma db seed
+```
+
+### 4. Running the App
+
+```bash
+# Debug Mode (Watch) - Best for Development
+npm run start:dev
+
+# Production Build & Run
+npm run build
+npm run start:prod
+```
+
+---
+
+## 🛡️ Response Standardization & Type Safety Protocol
+
+This boilerplate enforces a strict **"No-Leak"** policy for API responses to ensure both Security and Developer Experience.
+
+### 1. The `unknown` Type is Forbidden
+
+- **Rule:** Controllers must NEVER return `ApiResponse<unknown>` or raw Prisma entities.
+- **Why:** Returning raw entities risks exposing sensitive fields like `password` hashes or internal metadata. It also breaks contract visibility for frontend developers.
+
+### 2. DTO Pattern & Serialization
+
+- **Tool:** We use `class-transformer` for all response serialization.
+- **Implementation:**
+  - All Response DTOs must use `@Exclude()` class-level decorator.
+  - Only fields explicitly marked with `@Expose()` are returned to the client.
+  - Controllers use `plainToInstance(UserResponseDto, data)` before returning data.
+
+**Example:**
+
+```typescript
+// ✅ Good: Secure & Typed
+@Get('me')
+async getMe(@CurrentUser() user: User): Promise<ApiResponse<UserResponseDto>> {
+  return createSuccessResponse(plainToInstance(UserResponseDto, user));
+}
+
+// ❌ Bad: Leaks password hash & Weak Types
+@Get('me')
+async getMe(@CurrentUser() user: User) {
+  return createSuccessResponse(user);
+}
+```
+
+---
+
+## ⚡ High-Performance Caching (Redis Strategy)
+
+To ensure enterprise-grade performance, we utilize **Redis** for caching frequently accessed data (e.g., Roles, Permissions).
+
+- **Library:** `@nestjs/cache-manager` with `cache-manager-redis-yet` (Supports Redis v6+ / v7).
+- **Configuration:** Global Cache Module in `AppModule`.
+- **Strategy:** Read-heavy endpoints use `@UseInterceptors(CacheInterceptor)`.
+- **Invalidation:** Write operations (Create/Update/Delete) manually invalidate relevant cache keys.
+
+**Usage:**
+
+```typescript
+// 1. Automatic Caching
+@Get('roles')
+@UseInterceptors(CacheInterceptor)
+@CacheKey('roles_list') // Unique Key
+@CacheTTL(60000)        // 60 Seconds
+async getAllRoles() { ... }
+
+// 2. Manual Invalidation (Inject CACHE_MANAGER)
+async createRole(...) {
+  // ... create role logic
+  await this.cacheManager.del('roles_list'); // Clear cache
+}
+```
+
+---
+
+## 🤖 Gemini AI Integration (Optional)
+
+This boilerplate includes an **optional** AI module powered by Google's Gemini API. It's disabled by default and can be enabled during CLI setup or manually.
+
+### Configuration
+
+Add these to your `.env` file:
+
+```env
+# Enable Gemini AI features
+ENABLE_GEMINI=true
+
+# Your Google API Key (get from https://aistudio.google.com/apikey)
+GOOGLE_API_KEY=your-api-key-here
+
+# Model to use (optional, defaults to gemini-2.5-flash)
+GEMINI_MODEL=gemini-2.5-flash
+```
+
+### Usage
+
+The `GeminiService` is globally available when enabled:
+
+```typescript
+import { GeminiService } from './modules/gemini';
+
+@Injectable()
+export class MyService {
+  constructor(private readonly gemini: GeminiService) {}
+
+  async generateContent() {
+    // Check if Gemini is available
+    if (!this.gemini.isAvailable()) {
+      throw new Error('AI features are not enabled');
+    }
+
+    // 1. Simple Text Generation
+    const { text, usage } = await this.gemini.generateText(
+      'Write a product description for a coffee mug',
+    );
+
+    // 2. With System Prompt & Options
+    const { text } = await this.gemini.generateText('Translate: Hello World', {
+      systemPrompt: 'You are a professional Turkish translator',
+      temperature: 0.3,
+      maxTokens: 500,
+    });
+
+    // 3. Multi-turn Chat
+    const { text } = await this.gemini.chat([
+      { role: 'user', content: 'What is TypeScript?' },
+      {
+        role: 'model',
+        content: 'TypeScript is a typed superset of JavaScript...',
+      },
+      { role: 'user', content: 'Give me an example' },
+    ]);
+
+    // 4. Structured JSON Output
+    interface ProductData {
+      name: string;
+      price: number;
+      features: string[];
+    }
+
+    const { data } = await this.gemini.generateJSON<ProductData>(
+      'Generate a product entry for a wireless mouse',
+      '{ name: string, price: number, features: string[] }',
+    );
+    console.log(data.name, data.price); // Fully typed!
+  }
+}
+```
+
+### Available Methods
+
+| Method                                      | Description                                      |
+| ------------------------------------------- | ------------------------------------------------ |
+| `isAvailable()`                             | Check if Gemini is properly configured and ready |
+| `generateText(prompt, options?)`            | Generate text from a single prompt               |
+| `chat(messages, options?)`                  | Multi-turn conversation                          |
+| `generateJSON<T>(prompt, schema, options?)` | Generate and parse structured JSON               |
+
+### Options
+
+```typescript
+interface GeminiGenerateOptions {
+  model?: string; // Override default model
+  systemPrompt?: string; // System instructions
+  temperature?: number; // Creativity (0-1)
+  maxTokens?: number; // Max response length
+}
+```
+
+## 🌍 Internationalization (i18n) Guide
+
+Unique to this project is the deep integration of `nestjs-i18n`.
+
+- **Location:** `src/i18n/{lang}/`
+- **Files:**
+  - `common.json`: Generic messages (success, welcome)
+  - `errors.json`: Error codes (AUTH_REQUIRED, USER_NOT_FOUND)
+  - `validation.json`: Validation messages (IS_EMAIL)
+  - `auth.json`: Auth specific success messages (LOGIN_SUCCESS)
+
+**How to Translate a New Error:**
+
+1.  Throw an exception with a key: `throw new ConflictException('EMAIL_EXISTS');`
+2.  Add `"EMAIL_EXISTS": "Email already taken"` to `src/i18n/en/errors.json`.
+3.  Add Turkish translation to `src/i18n/tr/errors.json`.
+4.  Start server; the `GlobalExceptionFilter` handles the rest.
+
+---
+
+## 🧪 Testing & CI/CD
+
+- **GitHub Actions:** `.github/workflows/ci.yml` handles build and linting checks on push.
+- **Local Testing:**
+  ```bash
+  npm run test        # Unit tests
+  npm run test:e2e    # End-to-End tests
+  ```
+
+---
+
+## 📂 System Map (Directory Structure)
+
+```
+src/
+├── app.module.ts           # Root module (Redis, Config, i18n setup)
+├── main.ts                 # Entry point
+├── common/                 # Shared resources
+│   ├── base/               # Abstract BaseService & BaseController (CRUD)
+│   ├── types/              # Interfaces (ApiResponse, PaginatedData)
+│   ├── filters/            # Global Exception Filter
+│   └── interceptors/       # Response Interceptor
+├── config/                 # Application configuration
+├── database/               # Prisma Service
+├── i18n/                   # Localization assets
+└── modules/                # Feature modules
+    ├── admin/              # Admin capabilities (Roles, Permissions + Caching)
+    │   ├── admin.controller.ts
+    │   └── dto/            # Admin Response DTOs
+    ├── auth/               # Authentication layer
+    ├── gemini/             # 🤖 Optional AI module (Google Gemini)
+    ├── health/             # Health checks
+    └── users/              # User management
+```
+
+---
+
+## 🛠️ Troubleshooting (Known Issues)
+
+**1. `EADDRINUSE: address already in use`**
+
+- **Fix:** `lsof -ti:3000 | xargs kill -9`
+
+**2. `PrismaClientInitializationError` / Database Connection Hangs**
+
+- **Fix:** Check `.env` `DATABASE_URL`. Ensure `docker-compose up` is running.
+
+**3. Cache Manager Deprecation Warnings**
+
+- **Context:** `cache-manager-redis-yet` may show deprecation warnings regarding `Keyv`. This is expected as we wait for the ecosystem to stabilize on `cache-manager` v6/v7. The current implementation is fully functional.
+
+---
+
+## 📃 License
+
+This project is proprietary and confidential.
@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+*.egg
+dist/
+build/
+.eggs/
+
+# Virtual environment
+venv/
+.venv/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.*
+
+# Test & Coverage
+.pytest_cache/
+htmlcov/
+.coverage
+*.cover
+
+# Logs
+*.log
+
+# Training data (large CSVs)
+data/training_data*.csv
+
+# Reports (generated at runtime)
+reports/
@@ -0,0 +1,39 @@
+# --- AI Engine Dockerfile ---
+# Python 3.11 with v20+ prediction stack (XGBoost + LightGBM)
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# System dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    libpq-dev \
+    curl \
+    libgomp1 \
+    procps \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python dependencies
+# Install PyTorch CPU version separately to save space
+RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu
+
+# Copy requirements (without torch)
+COPY requirements-docker.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create models directory
+RUN mkdir -p /app/models
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health')" || exit 1
+
+# Start FastAPI with uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
@@ -0,0 +1,874 @@
+{
+"meta":{"test_sets":["test"],"test_metrics":[{"best_value":"Min","name":"Logloss"}],"learn_metrics":[{"best_value":"Min","name":"Logloss"}],"launch_mode":"Train","parameters":"","iteration_count":2000,"learn_sets":["learn"],"name":"experiment"},
+"iterations":[
+{"learn":[0.692389481],"iteration":0,"passed_time":0.04679785798,"remaining_time":93.54891809,"test":[0.6924099937]},
+{"learn":[0.6916338586],"iteration":1,"passed_time":0.08350330552,"remaining_time":83.41980222,"test":[0.6916660956]},
+{"learn":[0.6910159214],"iteration":2,"passed_time":0.132821758,"remaining_time":88.41501689,"test":[0.691108145]},
+{"learn":[0.6903417151],"iteration":3,"passed_time":0.162826233,"remaining_time":81.25029026,"test":[0.6904585078]},
+{"learn":[0.6896961461],"iteration":4,"passed_time":0.1969265393,"remaining_time":78.57368918,"test":[0.689812816]},
+{"learn":[0.6890979366],"iteration":5,"passed_time":0.2309352918,"remaining_time":76.74749531,"test":[0.689192261]},
+{"learn":[0.6884946167],"iteration":6,"passed_time":0.2693987513,"remaining_time":76.70167304,"test":[0.6886032715]},
+{"learn":[0.6879503686],"iteration":7,"passed_time":0.3199759681,"remaining_time":79.67401607,"test":[0.6880706742]},
+{"learn":[0.6874528094],"iteration":8,"passed_time":0.3645802206,"remaining_time":80.65324659,"test":[0.6876192378]},
+{"learn":[0.6869036785],"iteration":9,"passed_time":0.4116507506,"remaining_time":81.91849936,"test":[0.6870868859]},
+{"learn":[0.6863761921],"iteration":10,"passed_time":0.4562469316,"remaining_time":82.49774064,"test":[0.6865493528]},
+{"learn":[0.6859038678],"iteration":11,"passed_time":0.491541699,"remaining_time":81.43207481,"test":[0.686105086]},
+{"learn":[0.685410175],"iteration":12,"passed_time":0.5221556769,"remaining_time":79.80948692,"test":[0.6856345086]},
+{"learn":[0.6849483392],"iteration":13,"passed_time":0.5553110353,"remaining_time":78.77483686,"test":[0.6852027185]},
+{"learn":[0.6845417792],"iteration":14,"passed_time":0.5952927147,"remaining_time":78.77706925,"test":[0.6848238481]},
+{"learn":[0.6841038875],"iteration":15,"passed_time":0.6300274185,"remaining_time":78.12339989,"test":[0.6844045699]},
+{"learn":[0.6836957422],"iteration":16,"passed_time":0.662600544,"remaining_time":77.29040464,"test":[0.6840077621]},
+{"learn":[0.6832947461],"iteration":17,"passed_time":0.7004221698,"remaining_time":77.12426337,"test":[0.6836197496]},
+{"learn":[0.6829014105],"iteration":18,"passed_time":0.7300844347,"remaining_time":76.12090869,"test":[0.6832475033]},
+{"learn":[0.6825264546],"iteration":19,"passed_time":0.7641559459,"remaining_time":75.65143865,"test":[0.6829012069]},
+{"learn":[0.6822106577],"iteration":20,"passed_time":0.8040792063,"remaining_time":75.77489282,"test":[0.6825880966]},
+{"learn":[0.6818649349],"iteration":21,"passed_time":0.8356039756,"remaining_time":75.12839381,"test":[0.6822424968]},
+{"learn":[0.6815467855],"iteration":22,"passed_time":0.8861440327,"remaining_time":76.16985881,"test":[0.6819180513]},
+{"learn":[0.6812293319],"iteration":23,"passed_time":0.920219319,"remaining_time":75.76472393,"test":[0.6816384467]},
+{"learn":[0.6808837443],"iteration":24,"passed_time":0.960164738,"remaining_time":75.8530143,"test":[0.6813262593]},
+{"learn":[0.6805816494],"iteration":25,"passed_time":0.9895547925,"remaining_time":75.13004463,"test":[0.6810353411]},
+{"learn":[0.6803209634],"iteration":26,"passed_time":1.025550161,"remaining_time":74.94112844,"test":[0.6808138172]},
+{"learn":[0.6800350862],"iteration":27,"passed_time":1.060852064,"remaining_time":74.71429535,"test":[0.6805550049]},
+{"learn":[0.6797703947],"iteration":28,"passed_time":1.10467538,"remaining_time":75.07983357,"test":[0.680347991]},
+{"learn":[0.6794926675],"iteration":29,"passed_time":1.141766834,"remaining_time":74.97602208,"test":[0.680089679]},
+{"learn":[0.6792251865],"iteration":30,"passed_time":1.180421588,"remaining_time":74.9758099,"test":[0.6798451919]},
+{"learn":[0.6789670166],"iteration":31,"passed_time":1.213674604,"remaining_time":74.64098814,"test":[0.6796090443]},
+{"learn":[0.678722402],"iteration":32,"passed_time":1.245848393,"remaining_time":74.26011482,"test":[0.6793890865]},
+{"learn":[0.678476935],"iteration":33,"passed_time":1.287262512,"remaining_time":74.43406171,"test":[0.6791683772]},
+{"learn":[0.6782297335],"iteration":34,"passed_time":1.327473991,"remaining_time":74.52818262,"test":[0.6789766369]},
+{"learn":[0.6780226701],"iteration":35,"passed_time":1.3760549,"remaining_time":75.07143955,"test":[0.6787930242]},
+{"learn":[0.6778291026],"iteration":36,"passed_time":1.427620019,"remaining_time":75.74102965,"test":[0.6786087714]},
+{"learn":[0.6776045324],"iteration":37,"passed_time":1.468182407,"remaining_time":75.80457587,"test":[0.6784161299]},
+{"learn":[0.6773969079],"iteration":38,"passed_time":1.508647379,"remaining_time":75.85788487,"test":[0.6782227897]},
+{"learn":[0.6771819602],"iteration":39,"passed_time":1.549435187,"remaining_time":75.92232419,"test":[0.6780242369]},
+{"learn":[0.6769816736],"iteration":40,"passed_time":1.586036608,"remaining_time":75.78160282,"test":[0.6778499631]},
+{"learn":[0.6767984027],"iteration":41,"passed_time":1.621458864,"remaining_time":75.59086802,"test":[0.6776975784]},
+{"learn":[0.6766201184],"iteration":42,"passed_time":1.663424818,"remaining_time":75.70517136,"test":[0.6775231674]},
+{"learn":[0.6764394377],"iteration":43,"passed_time":1.70110089,"remaining_time":75.62166686,"test":[0.6773582124]},
+{"learn":[0.6762698797],"iteration":44,"passed_time":1.739954496,"remaining_time":75.59135644,"test":[0.6772234666]},
+{"learn":[0.6760974263],"iteration":45,"passed_time":1.776461223,"remaining_time":75.46098325,"test":[0.6770659843]},
+{"learn":[0.6759245179],"iteration":46,"passed_time":1.819761638,"remaining_time":75.61690381,"test":[0.6769049529]},
+{"learn":[0.6757673909],"iteration":47,"passed_time":1.869479807,"remaining_time":76.02551217,"test":[0.6767664194]},
+{"learn":[0.6756172628],"iteration":48,"passed_time":1.916010121,"remaining_time":76.28848462,"test":[0.6766584917]},
+{"learn":[0.675474531],"iteration":49,"passed_time":1.953635244,"remaining_time":76.19177452,"test":[0.6765507257]},
+{"learn":[0.6753286933],"iteration":50,"passed_time":1.993876686,"remaining_time":76.19736591,"test":[0.6764489911]},
+{"learn":[0.6751900513],"iteration":51,"passed_time":2.038943041,"remaining_time":76.38194316,"test":[0.6763947956]},
+{"learn":[0.6750574835],"iteration":52,"passed_time":2.080276765,"remaining_time":76.42073325,"test":[0.6762778712]},
+{"learn":[0.6749329567],"iteration":53,"passed_time":2.158576742,"remaining_time":77.78871001,"test":[0.6761865366]},
+{"learn":[0.6748033265],"iteration":54,"passed_time":2.220619687,"remaining_time":78.52918711,"test":[0.6760679685]},
+{"learn":[0.6746797823],"iteration":55,"passed_time":2.286959228,"remaining_time":79.39015604,"test":[0.6759774874]},
+{"learn":[0.674535525],"iteration":56,"passed_time":2.328472096,"remaining_time":79.3723032,"test":[0.6758500622]},
+{"learn":[0.6744256514],"iteration":57,"passed_time":2.367031568,"remaining_time":79.25474665,"test":[0.6757625065]},
+{"learn":[0.674310819],"iteration":58,"passed_time":2.409161286,"remaining_time":79.25732298,"test":[0.6756876412]},
+{"learn":[0.6741967947],"iteration":59,"passed_time":2.444825903,"remaining_time":79.04937087,"test":[0.6756151069]},
+{"learn":[0.6740879654],"iteration":60,"passed_time":2.48484996,"remaining_time":78.98564055,"test":[0.6755303655]},
+{"learn":[0.6739772476],"iteration":61,"passed_time":2.521603395,"remaining_time":78.8204416,"test":[0.6754565036]},
+{"learn":[0.67388281],"iteration":62,"passed_time":2.554102332,"remaining_time":78.5285114,"test":[0.6753738983]},
+{"learn":[0.6737789726],"iteration":63,"passed_time":2.593937938,"remaining_time":78.46662263,"test":[0.6752897299]},
+{"learn":[0.6736812332],"iteration":64,"passed_time":2.623889155,"remaining_time":78.11116175,"test":[0.6752115539]},
+{"learn":[0.6735930009],"iteration":65,"passed_time":2.660795108,"remaining_time":77.96935967,"test":[0.6751595431]},
+{"learn":[0.6734947116],"iteration":66,"passed_time":2.695822592,"remaining_time":77.77649358,"test":[0.6750764658]},
+{"learn":[0.6733961481],"iteration":67,"passed_time":2.725876686,"remaining_time":77.44696703,"test":[0.6750179194]},
+{"learn":[0.6732990195],"iteration":68,"passed_time":2.761848366,"remaining_time":77.29172746,"test":[0.6749408803]},
+{"learn":[0.6732133575],"iteration":69,"passed_time":2.791847449,"remaining_time":76.97522253,"test":[0.6748795802]},
+{"learn":[0.673111539],"iteration":70,"passed_time":2.824541003,"remaining_time":76.73999429,"test":[0.674790372]},
+{"learn":[0.6730080451],"iteration":71,"passed_time":2.861023716,"remaining_time":76.61185729,"test":[0.6747239773]},
+{"learn":[0.6729157861],"iteration":72,"passed_time":2.897136588,"remaining_time":76.47646857,"test":[0.6746701254]},
+{"learn":[0.6728347949],"iteration":73,"passed_time":2.935718661,"remaining_time":76.40802894,"test":[0.6746120937]},
+{"learn":[0.6727640693],"iteration":74,"passed_time":3.040023476,"remaining_time":78.02726921,"test":[0.6745550085]},
+{"learn":[0.6726808811],"iteration":75,"passed_time":3.097341794,"remaining_time":78.41165279,"test":[0.6744855074]},
+{"learn":[0.6726029645],"iteration":76,"passed_time":3.152948955,"remaining_time":78.74182909,"test":[0.6744264172]},
+{"learn":[0.6725356026],"iteration":77,"passed_time":3.216126808,"remaining_time":79.24866314,"test":[0.674381715]},
+{"learn":[0.6724606887],"iteration":78,"passed_time":3.256861302,"remaining_time":79.19532355,"test":[0.6743331681]},
+{"learn":[0.6723849561],"iteration":79,"passed_time":3.305679851,"remaining_time":79.33631641,"test":[0.67428564]},
+{"learn":[0.6723050519],"iteration":80,"passed_time":3.348083566,"remaining_time":79.32064647,"test":[0.6742202413]},
+{"learn":[0.6722508802],"iteration":81,"passed_time":3.38129387,"remaining_time":79.08928832,"test":[0.6741620971]},
+{"learn":[0.6721773904],"iteration":82,"passed_time":3.41660066,"remaining_time":78.91112609,"test":[0.6741109453]},
+{"learn":[0.6721007598],"iteration":83,"passed_time":3.48099347,"remaining_time":79.39980344,"test":[0.6740556003]},
+{"learn":[0.6720353564],"iteration":84,"passed_time":3.535359896,"remaining_time":79.64957884,"test":[0.6740146772]},
+{"learn":[0.6719790902],"iteration":85,"passed_time":3.581806996,"remaining_time":79.71603012,"test":[0.673983295]},
+{"learn":[0.6719140024],"iteration":86,"passed_time":3.612293661,"remaining_time":79.42893993,"test":[0.6739595301]},
+{"learn":[0.6718573633],"iteration":87,"passed_time":3.644530261,"remaining_time":79.18570293,"test":[0.6739336659]},
+{"learn":[0.671795602],"iteration":88,"passed_time":3.67809653,"remaining_time":78.97575809,"test":[0.673890361]},
+{"learn":[0.6717369134],"iteration":89,"passed_time":3.712417516,"remaining_time":78.78574951,"test":[0.673863586]},
+{"learn":[0.6716711079],"iteration":90,"passed_time":3.743502971,"remaining_time":78.53128759,"test":[0.6738190616]},
+{"learn":[0.6716070843],"iteration":91,"passed_time":3.775351679,"remaining_time":78.2975109,"test":[0.6737799295]},
+{"learn":[0.6715517232],"iteration":92,"passed_time":3.806186247,"remaining_time":78.04728142,"test":[0.6737364374]},
+{"learn":[0.6714957378],"iteration":93,"passed_time":3.83798807,"remaining_time":77.82133257,"test":[0.6737093719]},
+{"learn":[0.6714364567],"iteration":94,"passed_time":3.871278973,"remaining_time":77.62933099,"test":[0.6736630475]},
+{"learn":[0.6713881758],"iteration":95,"passed_time":3.913531039,"remaining_time":77.6183656,"test":[0.67364367]},
+{"learn":[0.6713336502],"iteration":96,"passed_time":3.945433866,"remaining_time":77.40371802,"test":[0.6735998081]},
+{"learn":[0.6712700267],"iteration":97,"passed_time":3.989716281,"remaining_time":77.43306496,"test":[0.6735526984]},
+{"learn":[0.6712154424],"iteration":98,"passed_time":4.020621946,"remaining_time":77.20406384,"test":[0.6735012924]},
+{"learn":[0.6711600413],"iteration":99,"passed_time":4.053732144,"remaining_time":77.02091074,"test":[0.6734818024]},
+{"learn":[0.6711060533],"iteration":100,"passed_time":4.084124711,"remaining_time":76.78963194,"test":[0.6734379341]},
+{"learn":[0.6710494943],"iteration":101,"passed_time":4.116434744,"remaining_time":76.59797199,"test":[0.6734059869]},
+{"learn":[0.6709936897],"iteration":102,"passed_time":4.148330356,"remaining_time":76.40177365,"test":[0.6733740852]},
+{"learn":[0.6709472183],"iteration":103,"passed_time":4.176511193,"remaining_time":76.14101176,"test":[0.6733330971]},
+{"learn":[0.6708914508],"iteration":104,"passed_time":4.2025065,"remaining_time":75.84523636,"test":[0.6733060254]},
+{"learn":[0.6708388195],"iteration":105,"passed_time":4.232975206,"remaining_time":75.63448151,"test":[0.6732755898]},
+{"learn":[0.6707885854],"iteration":106,"passed_time":4.261364958,"remaining_time":75.39031649,"test":[0.6732294722]},
+{"learn":[0.6707454167],"iteration":107,"passed_time":4.290824713,"remaining_time":75.1688922,"test":[0.6732035176]},
+{"learn":[0.6706973013],"iteration":108,"passed_time":4.324192493,"remaining_time":75.01878903,"test":[0.673196437]},
+{"learn":[0.6706577031],"iteration":109,"passed_time":4.351512102,"remaining_time":74.76688976,"test":[0.6731652709]},
+{"learn":[0.67061108],"iteration":110,"passed_time":4.38641502,"remaining_time":74.64808984,"test":[0.673138808]},
+{"learn":[0.6705625485],"iteration":111,"passed_time":4.424063991,"remaining_time":74.57707871,"test":[0.6731062725]},
+{"learn":[0.6705146484],"iteration":112,"passed_time":4.45863849,"remaining_time":74.45531709,"test":[0.6730726625]},
+{"learn":[0.6704704423],"iteration":113,"passed_time":4.497153675,"remaining_time":74.40027922,"test":[0.6730285927]},
+{"learn":[0.6704155922],"iteration":114,"passed_time":4.533368584,"remaining_time":74.30782417,"test":[0.6729872702]},
+{"learn":[0.6703687117],"iteration":115,"passed_time":4.564651269,"remaining_time":74.13623268,"test":[0.6729721425]},
+{"learn":[0.6703324232],"iteration":116,"passed_time":4.596824343,"remaining_time":73.98136956,"test":[0.6729564624]},
+{"learn":[0.6702884624],"iteration":117,"passed_time":4.628377967,"remaining_time":73.81870623,"test":[0.6729312424]},
+{"learn":[0.670253478],"iteration":118,"passed_time":4.668052254,"remaining_time":73.78660748,"test":[0.6729354345]},
+{"learn":[0.6702140804],"iteration":119,"passed_time":4.692108266,"remaining_time":73.50969617,"test":[0.6729085401]},
+{"learn":[0.6701682529],"iteration":120,"passed_time":4.723741667,"remaining_time":73.354633,"test":[0.6728898322]},
+{"learn":[0.6701320588],"iteration":121,"passed_time":4.756626425,"remaining_time":73.22085595,"test":[0.6728773638]},
+{"learn":[0.6700939824],"iteration":122,"passed_time":4.788008428,"remaining_time":73.06578714,"test":[0.6728618874]},
+{"learn":[0.6700655902],"iteration":123,"passed_time":4.815546648,"remaining_time":72.85456058,"test":[0.6728540413]},
+{"learn":[0.6700190743],"iteration":124,"passed_time":4.843186806,"remaining_time":72.64780209,"test":[0.6728441291]},
+{"learn":[0.6699792296],"iteration":125,"passed_time":4.875548614,"remaining_time":72.51411192,"test":[0.672815631]},
+{"learn":[0.6699379404],"iteration":126,"passed_time":4.916953662,"remaining_time":72.51538748,"test":[0.6728082021]},
+{"learn":[0.669895454],"iteration":127,"passed_time":4.952918369,"remaining_time":72.43643115,"test":[0.6727900064]},
+{"learn":[0.6698563938],"iteration":128,"passed_time":4.991585558,"remaining_time":72.39733782,"test":[0.6727649552]},
+{"learn":[0.6698215571],"iteration":129,"passed_time":5.028084166,"remaining_time":72.32705685,"test":[0.6727467657]},
+{"learn":[0.6697857067],"iteration":130,"passed_time":5.059198996,"remaining_time":72.18048033,"test":[0.6727396032]},
+{"learn":[0.6697449303],"iteration":131,"passed_time":5.096035515,"remaining_time":72.1166238,"test":[0.6727245271]},
+{"learn":[0.6697052425],"iteration":132,"passed_time":5.125282589,"remaining_time":71.94663604,"test":[0.6726955143]},
+{"learn":[0.6696695553],"iteration":133,"passed_time":5.156392608,"remaining_time":71.80469109,"test":[0.67269209]},
+{"learn":[0.6696269265],"iteration":134,"passed_time":5.190402292,"remaining_time":71.70444647,"test":[0.672677932]},
+{"learn":[0.6695969271],"iteration":135,"passed_time":5.221466142,"remaining_time":71.56480065,"test":[0.6726540285]},
+{"learn":[0.6695489786],"iteration":136,"passed_time":5.251144663,"remaining_time":71.40790151,"test":[0.6726288583]},
+{"learn":[0.6695173859],"iteration":137,"passed_time":5.274361693,"remaining_time":71.16566285,"test":[0.6725863431]},
+{"learn":[0.6694811164],"iteration":138,"passed_time":5.309398952,"remaining_time":71.08483058,"test":[0.6725837967]},
+{"learn":[0.6694477439],"iteration":139,"passed_time":5.344693175,"remaining_time":71.00806646,"test":[0.6725772977]},
+{"learn":[0.6694082161],"iteration":140,"passed_time":5.377737126,"remaining_time":70.90222211,"test":[0.6725685594]},
+{"learn":[0.6693679185],"iteration":141,"passed_time":5.416087925,"remaining_time":70.8668406,"test":[0.6725553829]},
+{"learn":[0.6693341916],"iteration":142,"passed_time":5.452286939,"remaining_time":70.80347444,"test":[0.6725484347]},
+{"learn":[0.6692933159],"iteration":143,"passed_time":5.490006789,"remaining_time":70.7600875,"test":[0.6725306172]},
+{"learn":[0.6692619696],"iteration":144,"passed_time":5.521869859,"remaining_time":70.64185233,"test":[0.672543149]},
+{"learn":[0.6692229289],"iteration":145,"passed_time":5.553520721,"remaining_time":70.5221056,"test":[0.6725196247]},
+{"learn":[0.6691840164],"iteration":146,"passed_time":5.582178524,"remaining_time":70.3658286,"test":[0.6725226452]},
+{"learn":[0.6691581406],"iteration":147,"passed_time":5.611368671,"remaining_time":70.21793769,"test":[0.6725056913]},
+{"learn":[0.6691177196],"iteration":148,"passed_time":5.636941079,"remaining_time":70.02669757,"test":[0.6724771476]},
+{"learn":[0.6690851126],"iteration":149,"passed_time":5.673704689,"remaining_time":69.97569117,"test":[0.6724439435]},
+{"learn":[0.6690518144],"iteration":150,"passed_time":5.706346207,"remaining_time":69.87439826,"test":[0.672442532]},
+{"learn":[0.6690149711],"iteration":151,"passed_time":5.738210991,"remaining_time":69.76456521,"test":[0.6724303064]},
+{"learn":[0.668993877],"iteration":152,"passed_time":5.765951318,"remaining_time":69.60596133,"test":[0.6724235788]},
+{"learn":[0.6689596579],"iteration":153,"passed_time":5.795573467,"remaining_time":69.47161442,"test":[0.6724294499]},
+{"learn":[0.6689372651],"iteration":154,"passed_time":5.81744896,"remaining_time":69.24640858,"test":[0.6724285935]},
+{"learn":[0.6689003045],"iteration":155,"passed_time":5.853529431,"remaining_time":69.19171968,"test":[0.6724172017]},
+{"learn":[0.6688680182],"iteration":156,"passed_time":5.888380392,"remaining_time":69.12283479,"test":[0.6724130745]},
+{"learn":[0.6688348164],"iteration":157,"passed_time":5.924601775,"remaining_time":69.07035741,"test":[0.6723860878]},
+{"learn":[0.6687947046],"iteration":158,"passed_time":5.964531924,"remaining_time":69.06102687,"test":[0.6723707604]},
+{"learn":[0.6687605251],"iteration":159,"passed_time":5.996805452,"remaining_time":68.9632627,"test":[0.6723566111]},
+{"learn":[0.668726253],"iteration":160,"passed_time":6.022341459,"remaining_time":68.78935368,"test":[0.6723469906]},
+{"learn":[0.6686862718],"iteration":161,"passed_time":6.05082584,"remaining_time":68.65072774,"test":[0.6723287161]},
+{"learn":[0.668663478],"iteration":162,"passed_time":6.079027554,"remaining_time":68.51026759,"test":[0.6723155898]},
+{"learn":[0.6686399521],"iteration":163,"passed_time":6.108511297,"remaining_time":68.38552891,"test":[0.6722970834]},
+{"learn":[0.6686058279],"iteration":164,"passed_time":6.140719309,"remaining_time":68.29224202,"test":[0.6722872244]},
+{"learn":[0.6685761282],"iteration":165,"passed_time":6.169540017,"remaining_time":68.16226742,"test":[0.6722800481]},
+{"learn":[0.6685469327],"iteration":166,"passed_time":6.2020892,"remaining_time":68.07442817,"test":[0.6722550973]},
+{"learn":[0.6685157003],"iteration":167,"passed_time":6.231576547,"remaining_time":67.95385854,"test":[0.6722394313]},
+{"learn":[0.6684805143],"iteration":168,"passed_time":6.263261652,"remaining_time":67.85817802,"test":[0.6722204135]},
+{"learn":[0.6684485765],"iteration":169,"passed_time":6.295102833,"remaining_time":67.7649305,"test":[0.6721982148]},
+{"learn":[0.6684144429],"iteration":170,"passed_time":6.325415964,"remaining_time":67.65605729,"test":[0.6721971176]},
+{"learn":[0.6683849752],"iteration":171,"passed_time":6.35697084,"remaining_time":67.56129474,"test":[0.6721880705]},
+{"learn":[0.6683568537],"iteration":172,"passed_time":6.395913563,"remaining_time":67.5452837,"test":[0.672179176]},
+{"learn":[0.6683266628],"iteration":173,"passed_time":6.437330522,"remaining_time":67.55497433,"test":[0.6721769709]},
+{"learn":[0.6682937842],"iteration":174,"passed_time":6.472195712,"remaining_time":67.49575528,"test":[0.6721693215]},
+{"learn":[0.6682657097],"iteration":175,"passed_time":6.503044842,"remaining_time":67.395192,"test":[0.6721581386]},
+{"learn":[0.6682301443],"iteration":176,"passed_time":6.533528251,"remaining_time":67.29164972,"test":[0.6721638661]},
+{"learn":[0.6681995916],"iteration":177,"passed_time":6.562589882,"remaining_time":67.17437509,"test":[0.6721598475]},
+{"learn":[0.6681658267],"iteration":178,"passed_time":6.590816982,"remaining_time":67.04959623,"test":[0.6721433342]},
+{"learn":[0.6681422687],"iteration":179,"passed_time":6.624646227,"remaining_time":66.98253407,"test":[0.6721335599]},
+{"learn":[0.6681216601],"iteration":180,"passed_time":6.655147334,"remaining_time":66.88239227,"test":[0.6721300594]},
+{"learn":[0.6680899019],"iteration":181,"passed_time":6.687788902,"remaining_time":66.80439684,"test":[0.6721153533]},
+{"learn":[0.6680676394],"iteration":182,"passed_time":6.718057043,"remaining_time":66.7033314,"test":[0.6721076397]},
+{"learn":[0.6680413672],"iteration":183,"passed_time":6.751300957,"remaining_time":66.6324051,"test":[0.6721009911]},
+{"learn":[0.6680088406],"iteration":184,"passed_time":6.784288393,"remaining_time":66.55936991,"test":[0.6720999252]},
+{"learn":[0.6679873982],"iteration":185,"passed_time":6.810905309,"remaining_time":66.42463565,"test":[0.6720953028]},
+{"learn":[0.6679663544],"iteration":186,"passed_time":6.832974292,"remaining_time":66.24696466,"test":[0.6720942505]},
+{"learn":[0.6679417375],"iteration":187,"passed_time":6.867184511,"remaining_time":66.18796986,"test":[0.6720856237]},
+{"learn":[0.6679100197],"iteration":188,"passed_time":6.918652024,"remaining_time":66.29459691,"test":[0.6720876136]},
+{"learn":[0.667881208],"iteration":189,"passed_time":6.96948149,"remaining_time":66.39348156,"test":[0.6720880182]},
+{"learn":[0.6678475427],"iteration":190,"passed_time":7.018176318,"remaining_time":66.47058094,"test":[0.6720743856]},
+{"learn":[0.6678310341],"iteration":191,"passed_time":7.074099623,"remaining_time":66.61443812,"test":[0.6720598415]},
+{"learn":[0.6678060257],"iteration":192,"passed_time":7.117099742,"remaining_time":66.63522919,"test":[0.6720563492]},
+{"learn":[0.6677789336],"iteration":193,"passed_time":7.191058554,"remaining_time":66.94356571,"test":[0.6720389527]},
+{"learn":[0.6677478773],"iteration":194,"passed_time":7.2421897,"remaining_time":67.03667902,"test":[0.6720317324]},
+{"learn":[0.6677212408],"iteration":195,"passed_time":7.282401129,"remaining_time":67.02781447,"test":[0.672000736]},
+{"learn":[0.667704316],"iteration":196,"passed_time":7.317019235,"remaining_time":66.96744,"test":[0.6719895017]},
+{"learn":[0.6676819639],"iteration":197,"passed_time":7.351194179,"remaining_time":66.90329248,"test":[0.6719725302]},
+{"learn":[0.6676554448],"iteration":198,"passed_time":7.389840926,"remaining_time":66.87991712,"test":[0.6719770493]},
+{"learn":[0.6676318346],"iteration":199,"passed_time":7.432994652,"remaining_time":66.89695187,"test":[0.6719667172]},
+{"learn":[0.6676074705],"iteration":200,"passed_time":7.471295231,"remaining_time":66.86995085,"test":[0.6719511616]},
+{"learn":[0.6675849784],"iteration":201,"passed_time":7.506377837,"remaining_time":66.8141948,"test":[0.6719427289]},
+{"learn":[0.6675631744],"iteration":202,"passed_time":7.540821494,"remaining_time":66.75298633,"test":[0.6719299116]},
+{"learn":[0.6675397619],"iteration":203,"passed_time":7.56808212,"remaining_time":66.62880141,"test":[0.6719106583]},
+{"learn":[0.6675169086],"iteration":204,"passed_time":7.605676901,"remaining_time":66.59604896,"test":[0.6718967065]},
+{"learn":[0.6674864762],"iteration":205,"passed_time":7.638300222,"remaining_time":66.51995436,"test":[0.671890967]},
+{"learn":[0.6674670714],"iteration":206,"passed_time":7.665554951,"remaining_time":66.39777791,"test":[0.6718896293]},
+{"learn":[0.6674375599],"iteration":207,"passed_time":7.700277678,"remaining_time":66.34085384,"test":[0.6718883534]},
+{"learn":[0.6674148457],"iteration":208,"passed_time":7.734145802,"remaining_time":66.27681881,"test":[0.6718827289]},
+{"learn":[0.6673974446],"iteration":209,"passed_time":7.766232144,"remaining_time":66.19788351,"test":[0.6718763224]},
+{"learn":[0.6673812139],"iteration":210,"passed_time":7.796801222,"remaining_time":66.1065279,"test":[0.67187262]},
+{"learn":[0.6673515687],"iteration":211,"passed_time":7.831891449,"remaining_time":66.05387693,"test":[0.6718590402]},
+{"learn":[0.6673197956],"iteration":212,"passed_time":7.871259964,"remaining_time":66.0372843,"test":[0.6718455115]},
+{"learn":[0.6672900754],"iteration":213,"passed_time":7.910110502,"remaining_time":66.01615587,"test":[0.6718253747]},
+{"learn":[0.6672550009],"iteration":214,"passed_time":7.951342226,"remaining_time":66.01463197,"test":[0.671794877]},
+{"learn":[0.6672271563],"iteration":215,"passed_time":7.989001461,"remaining_time":65.98323429,"test":[0.6717873786]},
+{"learn":[0.667204521],"iteration":216,"passed_time":8.025973631,"remaining_time":65.94613357,"test":[0.6717765089]},
+{"learn":[0.667181968],"iteration":217,"passed_time":8.058434478,"remaining_time":65.87215707,"test":[0.6717616726]},
+{"learn":[0.6671640023],"iteration":218,"passed_time":8.087145957,"remaining_time":65.76806826,"test":[0.6717499215]},
+{"learn":[0.66714351],"iteration":219,"passed_time":8.112590578,"remaining_time":65.63823286,"test":[0.6717326052]},
+{"learn":[0.6671167156],"iteration":220,"passed_time":8.148644349,"remaining_time":65.59474342,"test":[0.6717161937]},
+{"learn":[0.6670915937],"iteration":221,"passed_time":8.197662625,"remaining_time":65.65515382,"test":[0.6717056951]},
+{"learn":[0.6670595279],"iteration":222,"passed_time":8.239228431,"remaining_time":65.65519696,"test":[0.6717021438]},
+{"learn":[0.667033994],"iteration":223,"passed_time":8.268371203,"remaining_time":65.55637168,"test":[0.6716868488]},
+{"learn":[0.6670008246],"iteration":224,"passed_time":8.298555216,"remaining_time":65.46638004,"test":[0.6716751909]},
+{"learn":[0.6669858319],"iteration":225,"passed_time":8.327401394,"remaining_time":65.36641625,"test":[0.671670116]},
+{"learn":[0.6669553964],"iteration":226,"passed_time":8.357648377,"remaining_time":65.27802014,"test":[0.6716558757]},
+{"learn":[0.6669274683],"iteration":227,"passed_time":8.384989701,"remaining_time":65.16755154,"test":[0.6716559962]},
+{"learn":[0.666896348],"iteration":228,"passed_time":8.418297538,"remaining_time":65.1039517,"test":[0.6716487875]},
+{"learn":[0.6668698686],"iteration":229,"passed_time":8.453919972,"remaining_time":65.05842761,"test":[0.6716427451]},
+{"learn":[0.6668513411],"iteration":230,"passed_time":8.49049033,"remaining_time":65.02024846,"test":[0.6716323255]},
+{"learn":[0.6668309985],"iteration":231,"passed_time":8.523986676,"remaining_time":64.95865708,"test":[0.6716303547]},
+{"learn":[0.6668058585],"iteration":232,"passed_time":8.550998228,"remaining_time":64.84812819,"test":[0.6716309509]},
+{"learn":[0.6667845908],"iteration":233,"passed_time":8.575382398,"remaining_time":64.71848425,"test":[0.6716215401]},
+{"learn":[0.6667582863],"iteration":234,"passed_time":8.607602961,"remaining_time":64.64859245,"test":[0.6716162103]},
+{"learn":[0.6667332943],"iteration":235,"passed_time":8.6353786,"remaining_time":64.54579597,"test":[0.6716135097]},
+{"learn":[0.6667070085],"iteration":236,"passed_time":8.66085309,"remaining_time":64.42651476,"test":[0.6716156696]},
+{"learn":[0.6666907315],"iteration":237,"passed_time":8.691362456,"remaining_time":64.34529684,"test":[0.6716020054]},
+{"learn":[0.6666633028],"iteration":238,"passed_time":8.719983169,"remaining_time":64.25058728,"test":[0.6715921704]},
+{"learn":[0.6666406707],"iteration":239,"passed_time":8.746012652,"remaining_time":64.13742611,"test":[0.6715804466]},
+{"learn":[0.6666134624],"iteration":240,"passed_time":8.773898765,"remaining_time":64.03853912,"test":[0.6715882966]},
+{"learn":[0.6665850522],"iteration":241,"passed_time":8.803292064,"remaining_time":63.9511878,"test":[0.6715753942]},
+{"learn":[0.6665631193],"iteration":242,"passed_time":8.833976809,"remaining_time":63.87365125,"test":[0.6715752261]},
+{"learn":[0.6665412643],"iteration":243,"passed_time":8.862338006,"remaining_time":63.7797768,"test":[0.6715625509]},
+{"learn":[0.6665168385],"iteration":244,"passed_time":8.892424073,"remaining_time":63.69879285,"test":[0.6715628214]},
+{"learn":[0.6664904845],"iteration":245,"passed_time":8.932383667,"remaining_time":63.68862175,"test":[0.6715601629]},
+{"learn":[0.6664678274],"iteration":246,"passed_time":8.962911123,"remaining_time":63.61126801,"test":[0.6715576255]},
+{"learn":[0.6664539777],"iteration":247,"passed_time":8.991624872,"remaining_time":63.52147894,"test":[0.6715550274]},
+{"learn":[0.6664334121],"iteration":248,"passed_time":9.021847081,"remaining_time":63.44278811,"test":[0.6715448645]},
+{"learn":[0.6664121724],"iteration":249,"passed_time":9.05121341,"remaining_time":63.35849387,"test":[0.6715308166]},
+{"learn":[0.666392034],"iteration":250,"passed_time":9.085113431,"remaining_time":63.30622865,"test":[0.671519334]},
+{"learn":[0.666366899],"iteration":251,"passed_time":9.110250512,"remaining_time":63.19332498,"test":[0.6715184071]},
+{"learn":[0.6663414098],"iteration":252,"passed_time":9.137253573,"remaining_time":63.09399997,"test":[0.6715163019]},
+{"learn":[0.6663157816],"iteration":253,"passed_time":9.174559864,"remaining_time":63.06606899,"test":[0.6715096094]},
+{"learn":[0.6662989799],"iteration":254,"passed_time":9.196898204,"remaining_time":62.93563673,"test":[0.6714992963]},
+{"learn":[0.6662696102],"iteration":255,"passed_time":9.238149902,"remaining_time":62.9348962,"test":[0.6714917256]},
+{"learn":[0.6662479711],"iteration":256,"passed_time":9.267818291,"remaining_time":62.85528125,"test":[0.671477406]},
+{"learn":[0.6662231874],"iteration":257,"passed_time":9.297538986,"remaining_time":62.77640665,"test":[0.6714741542]},
+{"learn":[0.6661947927],"iteration":258,"passed_time":9.324772701,"remaining_time":62.68119411,"test":[0.6714576155]},
+{"learn":[0.6661669951],"iteration":259,"passed_time":9.357824574,"remaining_time":62.62544138,"test":[0.6714473645]},
+{"learn":[0.6661426137],"iteration":260,"passed_time":9.388345461,"remaining_time":62.55299907,"test":[0.6714427232]},
+{"learn":[0.6661216749],"iteration":261,"passed_time":9.427290804,"remaining_time":62.53676114,"test":[0.6714364275]},
+{"learn":[0.6660983123],"iteration":262,"passed_time":9.461913185,"remaining_time":62.49179925,"test":[0.6714339587]},
+{"learn":[0.6660803402],"iteration":263,"passed_time":9.496090562,"remaining_time":62.44398945,"test":[0.6714336287]},
+{"learn":[0.6660617842],"iteration":264,"passed_time":9.524189317,"remaining_time":62.35648477,"test":[0.6714283568]},
+{"learn":[0.6660443878],"iteration":265,"passed_time":9.55372419,"remaining_time":62.27878852,"test":[0.6714271895]},
+{"learn":[0.6660176079],"iteration":266,"passed_time":9.590356068,"remaining_time":62.2475171,"test":[0.671413471]},
+{"learn":[0.6659967546],"iteration":267,"passed_time":9.620235131,"remaining_time":62.17256436,"test":[0.6714072396]},
+{"learn":[0.6659751467],"iteration":268,"passed_time":9.645948482,"remaining_time":62.0711406,"test":[0.6714002677]},
+{"learn":[0.6659539329],"iteration":269,"passed_time":9.682675077,"remaining_time":62.04084401,"test":[0.6714001163]},
+{"learn":[0.6659263951],"iteration":270,"passed_time":9.711914203,"remaining_time":61.96272936,"test":[0.6713933952]},
+{"learn":[0.6659038921],"iteration":271,"passed_time":9.739142426,"remaining_time":61.87219894,"test":[0.6713926761]},
+{"learn":[0.6658767418],"iteration":272,"passed_time":9.768751964,"remaining_time":61.79719649,"test":[0.6713836619]},
+{"learn":[0.6658510507],"iteration":273,"passed_time":9.804576737,"remaining_time":61.76167682,"test":[0.6713772112]},
+{"learn":[0.6658210119],"iteration":274,"passed_time":9.848653906,"remaining_time":61.77791996,"test":[0.6713603715]},
+{"learn":[0.6657963011],"iteration":275,"passed_time":9.88663261,"remaining_time":61.75563268,"test":[0.6713560246]},
+{"learn":[0.6657748552],"iteration":276,"passed_time":9.925808942,"remaining_time":61.74068161,"test":[0.6713837913]},
+{"learn":[0.6657490013],"iteration":277,"passed_time":9.965409489,"remaining_time":61.72818396,"test":[0.6713684274]},
+{"learn":[0.665732402],"iteration":278,"passed_time":9.99537326,"remaining_time":61.65604796,"test":[0.6713619356]},
+{"learn":[0.6657118786],"iteration":279,"passed_time":10.02216777,"remaining_time":61.5647449,"test":[0.6713584836]},
+{"learn":[0.665684467],"iteration":280,"passed_time":10.05593393,"remaining_time":61.51654955,"test":[0.6713673572]},
+{"learn":[0.6656584634],"iteration":281,"passed_time":10.08025153,"remaining_time":61.41089406,"test":[0.6713625568]},
+{"learn":[0.6656309991],"iteration":282,"passed_time":10.11102202,"remaining_time":61.34496401,"test":[0.6713542652]},
+{"learn":[0.6656073482],"iteration":283,"passed_time":10.14714598,"remaining_time":61.31162855,"test":[0.6713512017]},
+{"learn":[0.6655890957],"iteration":284,"passed_time":10.17528061,"remaining_time":61.23019734,"test":[0.671342038]},
+{"learn":[0.6655665563],"iteration":285,"passed_time":10.2021403,"remaining_time":61.14149818,"test":[0.6713279798]},
+{"learn":[0.6655452454],"iteration":286,"passed_time":10.23423432,"remaining_time":61.08447174,"test":[0.6713123285]},
+{"learn":[0.6655255286],"iteration":287,"passed_time":10.26481698,"remaining_time":61.0186343,"test":[0.6713035326]},
+{"learn":[0.6655053548],"iteration":288,"passed_time":10.29945844,"remaining_time":60.97707056,"test":[0.6713022203]},
+{"learn":[0.6654893396],"iteration":289,"passed_time":10.32366496,"remaining_time":60.87402441,"test":[0.671296041]},
+{"learn":[0.6654648912],"iteration":290,"passed_time":10.35344703,"remaining_time":60.80426453,"test":[0.6712829551]},
+{"learn":[0.6654442759],"iteration":291,"passed_time":10.3949915,"remaining_time":60.8035804,"test":[0.6712769751]},
+{"learn":[0.6654173127],"iteration":292,"passed_time":10.43148765,"remaining_time":60.77320621,"test":[0.6712702915]},
+{"learn":[0.6653914518],"iteration":293,"passed_time":10.47162738,"remaining_time":60.76393303,"test":[0.6712379343]},
+{"learn":[0.6653648946],"iteration":294,"passed_time":10.50360107,"remaining_time":60.70725362,"test":[0.6712192006]},
+{"learn":[0.665344141],"iteration":295,"passed_time":10.53460819,"remaining_time":60.64517686,"test":[0.6712074061]},
+{"learn":[0.6653140817],"iteration":296,"passed_time":10.57659448,"remaining_time":60.64626395,"test":[0.6711953324]},
+{"learn":[0.665295365],"iteration":297,"passed_time":10.61260262,"remaining_time":60.61291829,"test":[0.6711891001]},
+{"learn":[0.6652787488],"iteration":298,"passed_time":10.63910358,"remaining_time":60.52546889,"test":[0.6711870526]},
+{"learn":[0.6652502991],"iteration":299,"passed_time":10.6681867,"remaining_time":60.45305797,"test":[0.6711812809]},
+{"learn":[0.665231168],"iteration":300,"passed_time":10.70260503,"remaining_time":60.41104967,"test":[0.6711768946]},
+{"learn":[0.6652136682],"iteration":301,"passed_time":10.72952096,"remaining_time":60.32690925,"test":[0.6711845012]},
+{"learn":[0.6651903001],"iteration":302,"passed_time":10.76489952,"remaining_time":60.29054288,"test":[0.6711869636]},
+{"learn":[0.6651697153],"iteration":303,"passed_time":10.80197155,"remaining_time":60.26363073,"test":[0.671186884]},
+{"learn":[0.6651525958],"iteration":304,"passed_time":10.82922271,"remaining_time":60.18207375,"test":[0.6711890401]},
+{"learn":[0.6651322685],"iteration":305,"passed_time":10.8578399,"remaining_time":60.10843394,"test":[0.6711868603]},
+{"learn":[0.6651113828],"iteration":306,"passed_time":10.89228879,"remaining_time":60.06724727,"test":[0.6711900892]},
+{"learn":[0.6650886807],"iteration":307,"passed_time":10.93056436,"remaining_time":60.04712628,"test":[0.6711884242]},
+{"learn":[0.6650622251],"iteration":308,"passed_time":10.97231236,"remaining_time":60.04589061,"test":[0.6711837119]},
+{"learn":[0.6650429987],"iteration":309,"passed_time":11.00296848,"remaining_time":59.98392494,"test":[0.6711766645]},
+{"learn":[0.665015513],"iteration":310,"passed_time":11.03002276,"remaining_time":59.90259947,"test":[0.671172959]},
+{"learn":[0.6650019022],"iteration":311,"passed_time":11.05828865,"remaining_time":59.82817707,"test":[0.6711740433]},
+{"learn":[0.664979951],"iteration":312,"passed_time":11.09287745,"remaining_time":59.78812863,"test":[0.6711715069]},
+{"learn":[0.6649549638],"iteration":313,"passed_time":11.1177757,"remaining_time":59.69608229,"test":[0.6711589843]},
+{"learn":[0.6649340455],"iteration":314,"passed_time":11.14959087,"remaining_time":59.64146228,"test":[0.6711446402]},
+{"learn":[0.6649162445],"iteration":315,"passed_time":11.18718772,"remaining_time":59.61779784,"test":[0.6711415366]},
+{"learn":[0.6649048119],"iteration":316,"passed_time":11.21179073,"remaining_time":59.52505932,"test":[0.6711359351]},
+{"learn":[0.6648796463],"iteration":317,"passed_time":11.24311165,"remaining_time":59.46828238,"test":[0.671143361]},
+{"learn":[0.6648605481],"iteration":318,"passed_time":11.27486028,"remaining_time":59.41391889,"test":[0.6711353638]},
+{"learn":[0.6648429084],"iteration":319,"passed_time":11.30400807,"remaining_time":59.34604237,"test":[0.6711444387]},
+{"learn":[0.6648238121],"iteration":320,"passed_time":11.33488419,"remaining_time":59.28744721,"test":[0.6711487352]},
+{"learn":[0.6647969527],"iteration":321,"passed_time":11.36208838,"remaining_time":59.20988915,"test":[0.67114436]},
+{"learn":[0.6647854723],"iteration":322,"passed_time":11.39429642,"remaining_time":59.15862259,"test":[0.6711444722]},
+{"learn":[0.6647589304],"iteration":323,"passed_time":11.4363998,"remaining_time":59.15866068,"test":[0.6711325635]},
+{"learn":[0.6647429024],"iteration":324,"passed_time":11.47751019,"remaining_time":59.15332173,"test":[0.6711269403]},
+{"learn":[0.6647237508],"iteration":325,"passed_time":11.5136833,"remaining_time":59.12241054,"test":[0.6711154078]},
+{"learn":[0.6647059396],"iteration":326,"passed_time":11.54795566,"remaining_time":59.08174257,"test":[0.6711203043]},
+{"learn":[0.664686288],"iteration":327,"passed_time":11.57245915,"remaining_time":58.99131613,"test":[0.6711241333]},
+{"learn":[0.6646532527],"iteration":328,"passed_time":11.60790333,"remaining_time":58.95685857,"test":[0.6711213497]},
+{"learn":[0.6646306438],"iteration":329,"passed_time":11.63787346,"remaining_time":58.89469298,"test":[0.6711231641]},
+{"learn":[0.6646098516],"iteration":330,"passed_time":11.66805718,"remaining_time":58.83379887,"test":[0.6711049215]},
+{"learn":[0.6645858284],"iteration":331,"passed_time":11.70070223,"remaining_time":58.78545579,"test":[0.6711031963]},
+{"learn":[0.6645707188],"iteration":332,"passed_time":11.724753,"remaining_time":58.69418391,"test":[0.6710996314]},
+{"learn":[0.6645485788],"iteration":333,"passed_time":11.75795297,"remaining_time":58.64895104,"test":[0.6710867309]},
+{"learn":[0.6645305696],"iteration":334,"passed_time":11.78053066,"remaining_time":58.55099567,"test":[0.6710914578]},
+{"learn":[0.6645108881],"iteration":335,"passed_time":11.81570271,"remaining_time":58.51586106,"test":[0.6710929585]},
+{"learn":[0.6644923286],"iteration":336,"passed_time":11.8448851,"remaining_time":58.45116888,"test":[0.6710984779]},
+{"learn":[0.6644805222],"iteration":337,"passed_time":11.86964023,"remaining_time":58.36491734,"test":[0.6710923199]},
+{"learn":[0.6644572776],"iteration":338,"passed_time":11.90591446,"remaining_time":58.33546879,"test":[0.6710893917]},
+{"learn":[0.6644320741],"iteration":339,"passed_time":11.94145444,"remaining_time":58.30239521,"test":[0.6710923306]},
+{"learn":[0.6644115048],"iteration":340,"passed_time":11.98658051,"remaining_time":58.31594449,"test":[0.6710927901]},
+{"learn":[0.6643949013],"iteration":341,"passed_time":12.02038848,"remaining_time":58.27428098,"test":[0.6711092802]},
+{"learn":[0.6643619789],"iteration":342,"passed_time":12.06653941,"remaining_time":58.29229096,"test":[0.6711012995]},
+{"learn":[0.6643389502],"iteration":343,"passed_time":12.12283646,"remaining_time":58.35877087,"test":[0.6711015305]},
+{"learn":[0.6643088915],"iteration":344,"passed_time":12.17733618,"remaining_time":58.41591705,"test":[0.6710975574]},
+{"learn":[0.664286972],"iteration":345,"passed_time":12.22133732,"remaining_time":58.42223099,"test":[0.6710899474]},
+{"learn":[0.664274149],"iteration":346,"passed_time":12.2642467,"remaining_time":58.42305415,"test":[0.671085152]},
+{"learn":[0.6642536926],"iteration":347,"passed_time":12.30091895,"remaining_time":58.39401755,"test":[0.6710814533]},
+{"learn":[0.6642357634],"iteration":348,"passed_time":12.32484094,"remaining_time":58.30462002,"test":[0.6710701892]},
+{"learn":[0.664207914],"iteration":349,"passed_time":12.35469303,"remaining_time":58.24355287,"test":[0.67105503]},
+{"learn":[0.6641853097],"iteration":350,"passed_time":12.40148755,"remaining_time":58.26225919,"test":[0.6710527861]},
+{"learn":[0.6641654917],"iteration":351,"passed_time":12.43803877,"remaining_time":58.23263605,"test":[0.6710508715]},
+{"learn":[0.664143804],"iteration":352,"passed_time":12.47995438,"remaining_time":58.22800245,"test":[0.6710560803]},
+{"learn":[0.6641290647],"iteration":353,"passed_time":12.51241326,"remaining_time":58.17918707,"test":[0.6710465693]},
+{"learn":[0.6641117244],"iteration":354,"passed_time":12.5417829,"remaining_time":58.11614893,"test":[0.6710440741]},
+{"learn":[0.6640880219],"iteration":355,"passed_time":12.5692936,"remaining_time":58.0447154,"test":[0.6710496913]},
+{"learn":[0.6640669415],"iteration":356,"passed_time":12.5976392,"remaining_time":57.97737034,"test":[0.6710404659]},
+{"learn":[0.6640462999],"iteration":357,"passed_time":12.62815847,"remaining_time":57.92021287,"test":[0.6710293986]},
+{"learn":[0.664030296],"iteration":358,"passed_time":12.65342509,"remaining_time":57.8391938,"test":[0.6710353817]},
+{"learn":[0.6640028542],"iteration":359,"passed_time":12.68233453,"remaining_time":57.77507954,"test":[0.6710271815]},
+{"learn":[0.6639813347],"iteration":360,"passed_time":12.72037964,"remaining_time":57.75263774,"test":[0.6710288077]},
+{"learn":[0.6639597941],"iteration":361,"passed_time":12.744473,"remaining_time":57.66698004,"test":[0.6710169894]},
+{"learn":[0.6639429832],"iteration":362,"passed_time":12.77086568,"remaining_time":57.59203063,"test":[0.6710119848]},
+{"learn":[0.6639222708],"iteration":363,"passed_time":12.81194554,"remaining_time":57.58335961,"test":[0.6710114775]},
+{"learn":[0.6639065546],"iteration":364,"passed_time":12.84133287,"remaining_time":57.52213492,"test":[0.6710013614]},
+{"learn":[0.6638823236],"iteration":365,"passed_time":12.87057337,"remaining_time":57.46042866,"test":[0.6709985657]},
+{"learn":[0.6638648195],"iteration":366,"passed_time":12.8971183,"remaining_time":57.38690512,"test":[0.6709948954]},
+{"learn":[0.6638436235],"iteration":367,"passed_time":12.93825161,"remaining_time":57.37833324,"test":[0.6709970591]},
+{"learn":[0.6638208732],"iteration":368,"passed_time":12.97444296,"remaining_time":57.3477411,"test":[0.6709739289]},
+{"learn":[0.6637956357],"iteration":369,"passed_time":13.00974924,"remaining_time":57.31321963,"test":[0.6709754911]},
+{"learn":[0.6637718453],"iteration":370,"passed_time":13.03832239,"remaining_time":57.24912984,"test":[0.6709717066]},
+{"learn":[0.663756918],"iteration":371,"passed_time":13.07843077,"remaining_time":57.23571316,"test":[0.67096845]},
+{"learn":[0.6637353525],"iteration":372,"passed_time":13.11729124,"remaining_time":57.21671005,"test":[0.6709739445]},
+{"learn":[0.6637143112],"iteration":373,"passed_time":13.14745329,"remaining_time":57.15978354,"test":[0.6709728881]},
+{"learn":[0.6636956547],"iteration":374,"passed_time":13.18118022,"remaining_time":57.11844761,"test":[0.6709694284]},
+{"learn":[0.663680995],"iteration":375,"passed_time":13.20539229,"remaining_time":57.03605604,"test":[0.6709604166]},
+{"learn":[0.66366728],"iteration":376,"passed_time":13.23563977,"remaining_time":56.97995583,"test":[0.6709605025]},
+{"learn":[0.6636487567],"iteration":377,"passed_time":13.27428255,"remaining_time":56.96001665,"test":[0.6709603727]},
+{"learn":[0.6636266904],"iteration":378,"passed_time":13.30625754,"remaining_time":56.91146033,"test":[0.670944339]},
+{"learn":[0.6636116064],"iteration":379,"passed_time":13.33327871,"remaining_time":56.84187241,"test":[0.6709447187]},
+{"learn":[0.6635902746],"iteration":380,"passed_time":13.36632239,"remaining_time":56.79809961,"test":[0.6709538679]},
+{"learn":[0.6635654896],"iteration":381,"passed_time":13.39639051,"remaining_time":56.74177969,"test":[0.6709640912]},
+{"learn":[0.6635393029],"iteration":382,"passed_time":13.42189438,"remaining_time":56.66632694,"test":[0.6709534847]},
+{"learn":[0.6635171734],"iteration":383,"passed_time":13.46730432,"remaining_time":56.6749057,"test":[0.6709471555]},
+{"learn":[0.663500789],"iteration":384,"passed_time":13.50832777,"remaining_time":56.66480351,"test":[0.6709506783]},
+{"learn":[0.663477743],"iteration":385,"passed_time":13.54029627,"remaining_time":56.61667921,"test":[0.6709546729]},
+{"learn":[0.6634584806],"iteration":386,"passed_time":13.56996301,"remaining_time":56.5590448,"test":[0.670930774]},
+{"learn":[0.6634337499],"iteration":387,"passed_time":13.59835745,"remaining_time":56.4962686,"test":[0.6709287322]},
+{"learn":[0.6634135584],"iteration":388,"passed_time":13.6279617,"remaining_time":56.43867943,"test":[0.6709198643]},
+{"learn":[0.6633868455],"iteration":389,"passed_time":13.65633448,"remaining_time":56.37615005,"test":[0.6709220389]},
+{"learn":[0.6633755323],"iteration":390,"passed_time":13.68565529,"remaining_time":56.31769658,"test":[0.6709230923]},
+{"learn":[0.663356103],"iteration":391,"passed_time":13.71789303,"remaining_time":56.27135714,"test":[0.670930414]},
+{"learn":[0.6633337631],"iteration":392,"passed_time":13.75060752,"remaining_time":56.2270389,"test":[0.6709354296]},
+{"learn":[0.663319422],"iteration":393,"passed_time":13.77167974,"remaining_time":56.13532403,"test":[0.6709351544]},
+{"learn":[0.6632911566],"iteration":394,"passed_time":13.80416242,"remaining_time":56.09033084,"test":[0.6709414935]},
+{"learn":[0.6632687875],"iteration":395,"passed_time":13.82525369,"remaining_time":55.9992599,"test":[0.6709445943]},
+{"learn":[0.6632431997],"iteration":396,"passed_time":13.85836516,"remaining_time":55.95707646,"test":[0.6709475685]},
+{"learn":[0.6632189331],"iteration":397,"passed_time":13.88898168,"remaining_time":55.90489613,"test":[0.6709533591]},
+{"learn":[0.663201035],"iteration":398,"passed_time":13.91726355,"remaining_time":55.84345598,"test":[0.6709592222]},
+{"learn":[0.6631898553],"iteration":399,"passed_time":13.95316828,"remaining_time":55.81267311,"test":[0.6709508704]},
+{"learn":[0.6631712482],"iteration":400,"passed_time":13.99418497,"remaining_time":55.80224881,"test":[0.6709479912]},
+{"learn":[0.663143025],"iteration":401,"passed_time":14.0253575,"remaining_time":55.75254052,"test":[0.6709417519]},
+{"learn":[0.663121538],"iteration":402,"passed_time":14.04844239,"remaining_time":55.67087467,"test":[0.6709476082]},
+{"learn":[0.6631087792],"iteration":403,"passed_time":14.0761289,"remaining_time":55.60767753,"test":[0.6709480979]},
+{"learn":[0.6630859067],"iteration":404,"passed_time":14.10555105,"remaining_time":55.55149118,"test":[0.6709448724]},
+{"learn":[0.663066483],"iteration":405,"passed_time":14.1427661,"remaining_time":55.52603242,"test":[0.6709421934]},
+{"learn":[0.6630443652],"iteration":406,"passed_time":14.18285552,"remaining_time":55.51176619,"test":[0.6709386261]},
+{"learn":[0.6630250376],"iteration":407,"passed_time":14.21458769,"remaining_time":55.46476372,"test":[0.6709461564]},
+{"learn":[0.6630007822],"iteration":408,"passed_time":14.24035708,"remaining_time":55.39464088,"test":[0.670934384]},
+{"learn":[0.6629768728],"iteration":409,"passed_time":14.26711915,"remaining_time":55.32858403,"test":[0.6709312987]},
+{"learn":[0.6629528093],"iteration":410,"passed_time":14.29943785,"remaining_time":55.28420133,"test":[0.670931806]},
+{"learn":[0.6629260936],"iteration":411,"passed_time":14.32489173,"remaining_time":55.21341763,"test":[0.6709286111]},
+{"learn":[0.6629102182],"iteration":412,"passed_time":14.35119075,"remaining_time":55.14610101,"test":[0.6709224729]},
+{"learn":[0.6628863488],"iteration":413,"passed_time":14.37946054,"remaining_time":55.08653242,"test":[0.6709236504]},
+{"learn":[0.6628648972],"iteration":414,"passed_time":14.41005914,"remaining_time":55.03600899,"test":[0.6709245901]},
+{"learn":[0.6628454339],"iteration":415,"passed_time":14.45103793,"remaining_time":55.02510598,"test":[0.6709463437]},
+{"learn":[0.6628200274],"iteration":416,"passed_time":14.48428995,"remaining_time":54.98472661,"test":[0.6709567049]},
+{"learn":[0.6627942591],"iteration":417,"passed_time":14.5135184,"remaining_time":54.92915339,"test":[0.670945606]},
+{"learn":[0.6627744647],"iteration":418,"passed_time":14.53698524,"remaining_time":54.85196578,"test":[0.6709479298]},
+{"learn":[0.662765485],"iteration":419,"passed_time":14.56542473,"remaining_time":54.79374067,"test":[0.6709464351]},
+{"learn":[0.6627503257],"iteration":420,"passed_time":14.58728594,"remaining_time":54.71098455,"test":[0.6709414048]},
+{"learn":[0.6627323029],"iteration":421,"passed_time":14.61501375,"remaining_time":54.65045425,"test":[0.6709414427]},
+{"learn":[0.6627111509],"iteration":422,"passed_time":14.64231614,"remaining_time":54.58849302,"test":[0.6709296343]},
+{"learn":[0.6626785863],"iteration":423,"passed_time":14.66665432,"remaining_time":54.51567739,"test":[0.670924721]},
+{"learn":[0.6626576561],"iteration":424,"passed_time":14.69050441,"remaining_time":54.44128104,"test":[0.670906284]},
+{"learn":[0.6626363113],"iteration":425,"passed_time":14.71910475,"remaining_time":54.38467341,"test":[0.6708996826]},
+{"learn":[0.6626181065],"iteration":426,"passed_time":14.73941058,"remaining_time":54.2976413,"test":[0.6708987677]},
+{"learn":[0.66259794],"iteration":427,"passed_time":14.77242451,"remaining_time":54.25759657,"test":[0.670909526]},
+{"learn":[0.6625765658],"iteration":428,"passed_time":14.79088688,"remaining_time":54.1642967,"test":[0.6709033226]},
+{"learn":[0.6625526572],"iteration":429,"passed_time":14.82430966,"remaining_time":54.12596783,"test":[0.6708750209]},
+{"learn":[0.66253135],"iteration":430,"passed_time":14.84439175,"remaining_time":54.03909666,"test":[0.6708752079]},
+{"learn":[0.6625035695],"iteration":431,"passed_time":14.8764415,"remaining_time":53.99597284,"test":[0.6708776566]},
+{"learn":[0.662480212],"iteration":432,"passed_time":14.90666075,"remaining_time":53.94627573,"test":[0.6708736133]},
+{"learn":[0.6624611632],"iteration":433,"passed_time":14.93845927,"remaining_time":53.90236684,"test":[0.6708754298]},
+{"learn":[0.6624332625],"iteration":434,"passed_time":14.98024104,"remaining_time":53.89443041,"test":[0.6708751084]},
+{"learn":[0.6624120584],"iteration":435,"passed_time":15.00605075,"remaining_time":53.82904442,"test":[0.6708642042]},
+{"learn":[0.6623941719],"iteration":436,"passed_time":15.03384083,"remaining_time":53.77092268,"test":[0.6708610465]},
+{"learn":[0.6623766304],"iteration":437,"passed_time":15.05972545,"remaining_time":53.70614417,"test":[0.6708574768]},
+{"learn":[0.6623623329],"iteration":438,"passed_time":15.08505889,"remaining_time":53.63958297,"test":[0.6708557953]},
+{"learn":[0.6623442925],"iteration":439,"passed_time":15.11080547,"remaining_time":53.57467393,"test":[0.670871378]},
+{"learn":[0.6623212715],"iteration":440,"passed_time":15.13466304,"remaining_time":53.50326458,"test":[0.6708640187]},
+{"learn":[0.6623025941],"iteration":441,"passed_time":15.16037021,"remaining_time":53.43859001,"test":[0.6708700565]},
+{"learn":[0.6622749791],"iteration":442,"passed_time":15.18471062,"remaining_time":53.36928767,"test":[0.6708667534]},
+{"learn":[0.6622534499],"iteration":443,"passed_time":15.21140556,"remaining_time":53.30843931,"test":[0.6708675383]},
+{"learn":[0.6622305473],"iteration":444,"passed_time":15.23498219,"remaining_time":53.23684787,"test":[0.6708740175]},
+{"learn":[0.6622059333],"iteration":445,"passed_time":15.26647355,"remaining_time":53.19304911,"test":[0.6708774523]},
+{"learn":[0.6621871707],"iteration":446,"passed_time":15.28793136,"remaining_time":53.11444609,"test":[0.6708697231]},
+{"learn":[0.6621638454],"iteration":447,"passed_time":15.31613827,"remaining_time":53.05947899,"test":[0.6708614971]},
+{"learn":[0.6621511296],"iteration":448,"passed_time":15.33689091,"remaining_time":52.9788815,"test":[0.6708607946]},
+{"learn":[0.6621349978],"iteration":449,"passed_time":15.36674634,"remaining_time":52.92990406,"test":[0.6708740865]},
+{"learn":[0.6621120424],"iteration":450,"passed_time":15.393642,"remaining_time":52.87084582,"test":[0.6708729562]},
+{"learn":[0.6620958271],"iteration":451,"passed_time":15.42984657,"remaining_time":52.84381082,"test":[0.6708674017]},
+{"learn":[0.6620793528],"iteration":452,"passed_time":15.46956188,"remaining_time":52.82872456,"test":[0.6708693088]},
+{"learn":[0.6620572713],"iteration":453,"passed_time":15.49032259,"remaining_time":52.74898396,"test":[0.6708712037]},
+{"learn":[0.6620395025],"iteration":454,"passed_time":15.52379393,"remaining_time":52.71266289,"test":[0.6708703905]},
+{"learn":[0.6620188044],"iteration":455,"passed_time":15.55053135,"remaining_time":52.65355352,"test":[0.6708577595]},
+{"learn":[0.6620017347],"iteration":456,"passed_time":15.57735398,"remaining_time":52.59487352,"test":[0.6708493546]},
+{"learn":[0.6619811454],"iteration":457,"passed_time":15.60434803,"remaining_time":52.53690973,"test":[0.6708523777]},
+{"learn":[0.6619695569],"iteration":458,"passed_time":15.63056555,"remaining_time":52.47647387,"test":[0.6708454134]},
+{"learn":[0.661952377],"iteration":459,"passed_time":15.656355,"remaining_time":52.41475368,"test":[0.6708404483]},
+{"learn":[0.6619237442],"iteration":460,"passed_time":15.68232112,"remaining_time":52.35377918,"test":[0.6708274771]},
+{"learn":[0.6619089407],"iteration":461,"passed_time":15.71164945,"remaining_time":52.30414904,"test":[0.6708244992]},
+{"learn":[0.6618886168],"iteration":462,"passed_time":15.7361944,"remaining_time":52.23872743,"test":[0.6708344314]},
+{"learn":[0.6618831383],"iteration":463,"passed_time":15.76527735,"remaining_time":52.18850433,"test":[0.6708279081]},
+{"learn":[0.6618690774],"iteration":464,"passed_time":15.78652262,"remaining_time":52.11249942,"test":[0.6708258106]},
+{"learn":[0.661845878],"iteration":465,"passed_time":15.81756836,"remaining_time":52.06899113,"test":[0.6708049714]},
+{"learn":[0.6618290213],"iteration":466,"passed_time":15.83979966,"remaining_time":51.99660146,"test":[0.670810989]},
+{"learn":[0.6618050064],"iteration":467,"passed_time":15.87342473,"remaining_time":51.9617237,"test":[0.6708212237]},
+{"learn":[0.6617832833],"iteration":468,"passed_time":15.90381555,"remaining_time":51.9162934,"test":[0.6708221741]},
+{"learn":[0.6617652311],"iteration":469,"passed_time":15.93502938,"remaining_time":51.87360627,"test":[0.6708259658]},
+{"learn":[0.6617443144],"iteration":470,"passed_time":15.96919221,"remaining_time":51.84054117,"test":[0.6708159692]},
+{"learn":[0.6617202619],"iteration":471,"passed_time":15.99477329,"remaining_time":51.77968981,"test":[0.6708136212]},
+{"learn":[0.6617005831],"iteration":472,"passed_time":16.02279091,"remaining_time":51.72685354,"test":[0.6708224942]},
+{"learn":[0.6616824419],"iteration":473,"passed_time":16.04763422,"remaining_time":51.66390258,"test":[0.6708363084]},
+{"learn":[0.6616538226],"iteration":474,"passed_time":16.07374645,"remaining_time":51.60518598,"test":[0.670850875]},
+{"learn":[0.6616314155],"iteration":475,"passed_time":16.09993591,"remaining_time":51.54685363,"test":[0.6708527236]},
+{"learn":[0.6616127861],"iteration":476,"passed_time":16.12811357,"remaining_time":51.49500411,"test":[0.6708453401]},
+{"learn":[0.6616029072],"iteration":477,"passed_time":16.15264086,"remaining_time":51.43163051,"test":[0.6708413844]},
+{"learn":[0.6615843751],"iteration":478,"passed_time":16.17696751,"remaining_time":51.36778201,"test":[0.6708364569]},
+{"learn":[0.661563216],"iteration":479,"passed_time":16.20551145,"remaining_time":51.31745293,"test":[0.6708251774]},
+{"learn":[0.6615432257],"iteration":480,"passed_time":16.22860577,"remaining_time":51.2500045,"test":[0.6708154393]},
+{"learn":[0.6615263324],"iteration":481,"passed_time":16.25544093,"remaining_time":51.19452144,"test":[0.6708111613]},
+{"learn":[0.6615033259],"iteration":482,"passed_time":16.27729221,"remaining_time":51.12350369,"test":[0.6708102339]},
+{"learn":[0.661484293],"iteration":483,"passed_time":16.30502335,"remaining_time":51.07110619,"test":[0.6707929623]},
+{"learn":[0.6614678231],"iteration":484,"passed_time":16.32842702,"remaining_time":51.00529266,"test":[0.6707900226]},
+{"learn":[0.6614463024],"iteration":485,"passed_time":16.36272839,"remaining_time":50.97360242,"test":[0.6707832384]},
+{"learn":[0.6614155436],"iteration":486,"passed_time":16.39272506,"remaining_time":50.92852776,"test":[0.6707739118]},
+{"learn":[0.6613958945],"iteration":487,"passed_time":16.42636604,"remaining_time":50.89480625,"test":[0.6707737538]},
+{"learn":[0.661380611],"iteration":488,"passed_time":16.4597142,"remaining_time":50.86018027,"test":[0.6707730234]},
+{"learn":[0.6613677802],"iteration":489,"passed_time":16.48056007,"remaining_time":50.78703206,"test":[0.6707796291]},
+{"learn":[0.6613530086],"iteration":490,"passed_time":16.51091177,"remaining_time":50.74331132,"test":[0.670791408]},
+{"learn":[0.6613248211],"iteration":491,"passed_time":16.53097438,"remaining_time":50.66810846,"test":[0.6707944906]},
+{"learn":[0.6613059359],"iteration":492,"passed_time":16.56161402,"remaining_time":50.62546112,"test":[0.6707835635]},
+{"learn":[0.6612729965],"iteration":493,"passed_time":16.5854633,"remaining_time":50.56216139,"test":[0.6707908928]},
+{"learn":[0.6612624948],"iteration":494,"passed_time":16.61302735,"remaining_time":50.51031547,"test":[0.670796262]},
+{"learn":[0.6612401679],"iteration":495,"passed_time":16.63896978,"remaining_time":50.45365029,"test":[0.6707877825]},
+{"learn":[0.6612191637],"iteration":496,"passed_time":16.663707,"remaining_time":50.39346403,"test":[0.6707854132]},
+{"learn":[0.6611912219],"iteration":497,"passed_time":16.69040179,"remaining_time":50.33932428,"test":[0.6707756206]},
+{"learn":[0.6611773017],"iteration":498,"passed_time":16.71612789,"remaining_time":50.28238068,"test":[0.6707707899]},
+{"learn":[0.6611638216],"iteration":499,"passed_time":16.74072553,"remaining_time":50.2221766,"test":[0.6707704386]},
+{"learn":[0.6611450533],"iteration":500,"passed_time":16.77346538,"remaining_time":50.18647626,"test":[0.6707621465]},
+{"learn":[0.6611179111],"iteration":501,"passed_time":16.80230735,"remaining_time":50.13915621,"test":[0.6707661931]},
+{"learn":[0.6610959069],"iteration":502,"passed_time":16.83637769,"remaining_time":50.10747,"test":[0.6707651988]},
+{"learn":[0.6610728788],"iteration":503,"passed_time":16.87382128,"remaining_time":50.08578697,"test":[0.6707607827]},
+{"learn":[0.6610436668],"iteration":504,"passed_time":16.92151611,"remaining_time":50.09438927,"test":[0.670760242]},
+{"learn":[0.6610188976],"iteration":505,"passed_time":16.9898618,"remaining_time":50.16374216,"test":[0.6707506008]},
+{"learn":[0.6610030555],"iteration":506,"passed_time":17.03818668,"remaining_time":50.17359509,"test":[0.6707452886]},
+{"learn":[0.6609831174],"iteration":507,"passed_time":17.06933058,"remaining_time":50.13275833,"test":[0.6707355189]},
+{"learn":[0.6609586562],"iteration":508,"passed_time":17.1106164,"remaining_time":50.12166807,"test":[0.6707312551]},
+{"learn":[0.660935882],"iteration":509,"passed_time":17.14537899,"remaining_time":50.09140137,"test":[0.6707199485]},
+{"learn":[0.6609202024],"iteration":510,"passed_time":17.19066307,"remaining_time":50.09177556,"test":[0.6707131947]},
+{"learn":[0.6609011137],"iteration":511,"passed_time":17.21958034,"remaining_time":50.04440537,"test":[0.6707154112]},
+{"learn":[0.6608726737],"iteration":512,"passed_time":17.24756917,"remaining_time":49.99441591,"test":[0.6706982346]},
+{"learn":[0.6608608849],"iteration":513,"passed_time":17.27150822,"remaining_time":49.93280391,"test":[0.6706988941]},
+{"learn":[0.6608387256],"iteration":514,"passed_time":17.29800365,"remaining_time":49.87870957,"test":[0.6706989098]},
+{"learn":[0.6608136063],"iteration":515,"passed_time":17.34332283,"remaining_time":49.87885868,"test":[0.670693306]},
+{"learn":[0.6607946343],"iteration":516,"passed_time":17.37393636,"remaining_time":49.83664916,"test":[0.6706944515]},
+{"learn":[0.6607703935],"iteration":517,"passed_time":17.4173655,"remaining_time":49.83114994,"test":[0.6706899688]},
+{"learn":[0.6607509625],"iteration":518,"passed_time":17.46008645,"remaining_time":49.82348368,"test":[0.6706909374]},
+{"learn":[0.6607238109],"iteration":519,"passed_time":17.4906988,"remaining_time":49.78121967,"test":[0.6706855074]},
+{"learn":[0.6606999858],"iteration":520,"passed_time":17.5186435,"remaining_time":49.7314275,"test":[0.6706787779]},
+{"learn":[0.6606813873],"iteration":521,"passed_time":17.54613056,"remaining_time":49.6804233,"test":[0.6706737082]},
+{"learn":[0.6606610372],"iteration":522,"passed_time":17.57100039,"remaining_time":49.62211774,"test":[0.6706761225]},
+{"learn":[0.660638456],"iteration":523,"passed_time":17.60084283,"remaining_time":49.5779466,"test":[0.670685455]},
+{"learn":[0.6606156483],"iteration":524,"passed_time":17.62599925,"remaining_time":49.52066456,"test":[0.6706693855]},
+{"learn":[0.6605968623],"iteration":525,"passed_time":17.65519625,"remaining_time":49.47482751,"test":[0.6706647216]},
+{"learn":[0.6605735776],"iteration":526,"passed_time":17.67910836,"remaining_time":49.41428199,"test":[0.6706569188]},
+{"learn":[0.6605517294],"iteration":527,"passed_time":17.70744827,"remaining_time":49.36621942,"test":[0.6706549134]},
+{"learn":[0.6605309239],"iteration":528,"passed_time":17.72943083,"remaining_time":49.3005534,"test":[0.6706547978]},
+{"learn":[0.6605086434],"iteration":529,"passed_time":17.75830336,"remaining_time":49.25416215,"test":[0.6706564214]},
+{"learn":[0.6604803349],"iteration":530,"passed_time":17.78141858,"remaining_time":49.19190939,"test":[0.6706559196]},
+{"learn":[0.6604566326],"iteration":531,"passed_time":17.80870208,"remaining_time":49.14130574,"test":[0.6706515072]},
+{"learn":[0.6604430839],"iteration":532,"passed_time":17.82904188,"remaining_time":49.07167811,"test":[0.6706474616]},
+{"learn":[0.6604273738],"iteration":533,"passed_time":17.86246645,"remaining_time":49.03815696,"test":[0.6706424204]},
+{"learn":[0.6604048016],"iteration":534,"passed_time":17.90552779,"remaining_time":49.03102469,"test":[0.6706520008]},
+{"learn":[0.6603845173],"iteration":535,"passed_time":18.02843143,"remaining_time":49.24183511,"test":[0.6706448306]},
+{"learn":[0.6603669212],"iteration":536,"passed_time":18.07245966,"remaining_time":49.23651485,"test":[0.6706415789]},
+{"learn":[0.6603488983],"iteration":537,"passed_time":18.10631942,"remaining_time":49.20341819,"test":[0.6706305359]},
+{"learn":[0.6603176881],"iteration":538,"passed_time":18.13531438,"remaining_time":49.1571323,"test":[0.6706152774]},
+{"learn":[0.6602953862],"iteration":539,"passed_time":18.16575265,"remaining_time":49.11481272,"test":[0.670616585]},
+{"learn":[0.6602672025],"iteration":540,"passed_time":18.20025584,"remaining_time":49.08349958,"test":[0.6705963243]},
+{"learn":[0.6602568636],"iteration":541,"passed_time":18.22381751,"remaining_time":49.02274158,"test":[0.6706027368]},
+{"learn":[0.660235705],"iteration":542,"passed_time":18.25438575,"remaining_time":48.98092088,"test":[0.6706003522]},
+{"learn":[0.6602152295],"iteration":543,"passed_time":18.28070524,"remaining_time":48.9277699,"test":[0.6706044301]},
+{"learn":[0.6601897709],"iteration":544,"passed_time":18.30768805,"remaining_time":48.87648827,"test":[0.6706047241]},
+{"learn":[0.6601683731],"iteration":545,"passed_time":18.33807201,"remaining_time":48.83435294,"test":[0.6706038235]},
+{"learn":[0.6601472267],"iteration":546,"passed_time":18.36776304,"remaining_time":48.79041993,"test":[0.6706026913]},
+{"learn":[0.6601262337],"iteration":547,"passed_time":18.41134623,"remaining_time":48.78334803,"test":[0.6705845786]},
+{"learn":[0.6601119991],"iteration":548,"passed_time":18.44405381,"remaining_time":48.74739905,"test":[0.6705873967]},
+{"learn":[0.6600869973],"iteration":549,"passed_time":18.47010718,"remaining_time":48.69391893,"test":[0.6705755426]},
+{"learn":[0.6600667497],"iteration":550,"passed_time":18.5036553,"remaining_time":48.66024779,"test":[0.6705715731]},
+{"learn":[0.6600397508],"iteration":551,"passed_time":18.53164471,"remaining_time":48.61199556,"test":[0.6705757153]},
+{"learn":[0.660016863],"iteration":552,"passed_time":18.5577607,"remaining_time":48.55891452,"test":[0.6705516814]},
+{"learn":[0.6599933158],"iteration":553,"passed_time":18.58492994,"remaining_time":48.50867995,"test":[0.6705530864]},
+{"learn":[0.6599632649],"iteration":554,"passed_time":18.62562092,"remaining_time":48.49373376,"test":[0.6705552479]},
+{"learn":[0.6599446007],"iteration":555,"passed_time":18.65010209,"remaining_time":48.43659608,"test":[0.6705563336]},
+{"learn":[0.6599138126],"iteration":556,"passed_time":18.67796421,"remaining_time":48.38833458,"test":[0.6705718544]},
+{"learn":[0.6598965504],"iteration":557,"passed_time":18.70319381,"remaining_time":48.33334314,"test":[0.6705688384]},
+{"learn":[0.6598785723],"iteration":558,"passed_time":18.72995694,"remaining_time":48.28241136,"test":[0.6705641528]},
+{"learn":[0.659860838],"iteration":559,"passed_time":18.75657945,"remaining_time":48.23120429,"test":[0.6705628467]},
+{"learn":[0.6598408724],"iteration":560,"passed_time":18.78181322,"remaining_time":48.17652269,"test":[0.670558488]},
+{"learn":[0.6598244857],"iteration":561,"passed_time":18.80867415,"remaining_time":48.12610931,"test":[0.6705544404]},
+{"learn":[0.6598082469],"iteration":562,"passed_time":18.83488797,"remaining_time":48.0741279,"test":[0.6705617451]},
+{"learn":[0.6597851673],"iteration":563,"passed_time":18.86939449,"remaining_time":48.04335193,"test":[0.6705631717]},
+{"learn":[0.6597683521],"iteration":564,"passed_time":18.90235988,"remaining_time":48.00864854,"test":[0.6705636201]},
+{"learn":[0.6597479006],"iteration":565,"passed_time":18.93001053,"remaining_time":47.96048604,"test":[0.6705537522]},
+{"learn":[0.6597310938],"iteration":566,"passed_time":18.95858079,"remaining_time":47.91472006,"test":[0.670555083]},
+{"learn":[0.6597096581],"iteration":567,"passed_time":18.9833487,"remaining_time":47.85942842,"test":[0.6705524541]},
+{"learn":[0.6596862311],"iteration":568,"passed_time":19.0162481,"remaining_time":47.82469425,"test":[0.6705503132]},
+{"learn":[0.6596574779],"iteration":569,"passed_time":19.03781666,"remaining_time":47.76154004,"test":[0.6705354602]},
+{"learn":[0.6596385418],"iteration":570,"passed_time":19.0681355,"remaining_time":47.72043018,"test":[0.6705387012]},
+{"learn":[0.6596189903],"iteration":571,"passed_time":19.09073714,"remaining_time":47.66009201,"test":[0.6705411923]},
+{"learn":[0.65959275],"iteration":572,"passed_time":19.11146842,"remaining_time":47.59522765,"test":[0.6705390018]},
+{"learn":[0.6595730662],"iteration":573,"passed_time":19.141368,"remaining_time":47.55329403,"test":[0.6705354939]},
+{"learn":[0.6595566809],"iteration":574,"passed_time":19.16428373,"remaining_time":47.49409447,"test":[0.670531296]},
+{"learn":[0.6595365076],"iteration":575,"passed_time":19.19652276,"remaining_time":47.45807015,"test":[0.6705377163]},
+{"learn":[0.6595163446],"iteration":576,"passed_time":19.21727405,"remaining_time":47.39372785,"test":[0.6705248875]},
+{"learn":[0.6594816637],"iteration":577,"passed_time":19.24969594,"remaining_time":47.35824848,"test":[0.6705252902]},
+{"learn":[0.6594570142],"iteration":578,"passed_time":19.27445137,"remaining_time":47.30396442,"test":[0.6705181562]},
+{"learn":[0.6594353055],"iteration":579,"passed_time":19.29822455,"remaining_time":47.24737734,"test":[0.6705123446]},
+{"learn":[0.6594162362],"iteration":580,"passed_time":19.32403522,"remaining_time":47.19587948,"test":[0.6705128345]},
+{"learn":[0.659395036],"iteration":581,"passed_time":19.35739555,"remaining_time":47.16286408,"test":[0.6705173712]},
+{"learn":[0.6593798831],"iteration":582,"passed_time":19.39112791,"remaining_time":47.13075172,"test":[0.670541941]},
+{"learn":[0.6593556719],"iteration":583,"passed_time":19.42704318,"remaining_time":47.1039266,"test":[0.6705463243]},
+{"learn":[0.6593292627],"iteration":584,"passed_time":19.46022169,"remaining_time":47.07045077,"test":[0.6705513215]},
+{"learn":[0.6592976737],"iteration":585,"passed_time":19.48332075,"remaining_time":47.01265452,"test":[0.6705455889]},
+{"learn":[0.6592754841],"iteration":586,"passed_time":19.5115578,"remaining_time":46.9673444,"test":[0.6705408087]},
+{"learn":[0.6592510441],"iteration":587,"passed_time":19.54275193,"remaining_time":46.92919341,"test":[0.6705510193]},
+{"learn":[0.6592290326],"iteration":588,"passed_time":19.56411389,"remaining_time":46.86751222,"test":[0.6705456751]},
+{"learn":[0.6592097404],"iteration":589,"passed_time":19.59700884,"remaining_time":46.8335296,"test":[0.6705402427]},
+{"learn":[0.6591876204],"iteration":590,"passed_time":19.62169623,"remaining_time":46.77998306,"test":[0.6705443402]},
+{"learn":[0.6591705995],"iteration":591,"passed_time":19.64747626,"remaining_time":46.72913272,"test":[0.67054441]},
+{"learn":[0.6591456195],"iteration":592,"passed_time":19.67090184,"remaining_time":46.67278059,"test":[0.6705441955]},
+{"learn":[0.6591107122],"iteration":593,"passed_time":19.69910949,"remaining_time":46.62785848,"test":[0.6705319356]},
+{"learn":[0.6590819533],"iteration":594,"passed_time":19.72694709,"remaining_time":46.58211876,"test":[0.6705358843]},
+{"learn":[0.6590551327],"iteration":595,"passed_time":19.7530808,"remaining_time":46.53242523,"test":[0.6705334396]},
+{"learn":[0.6590373916],"iteration":596,"passed_time":19.77835609,"remaining_time":46.48079328,"test":[0.6705320462]},
+{"learn":[0.6590177149],"iteration":597,"passed_time":19.80378809,"remaining_time":46.4296169,"test":[0.6705332043]},
+{"learn":[0.6589946095],"iteration":598,"passed_time":19.83052585,"remaining_time":46.38158048,"test":[0.6705328363]},
+{"learn":[0.6589697628],"iteration":599,"passed_time":19.8579153,"remaining_time":46.33513569,"test":[0.6705315638]},
+{"learn":[0.6589442269],"iteration":600,"passed_time":19.89600309,"remaining_time":46.31365777,"test":[0.6705274435]},
+{"learn":[0.6589182437],"iteration":601,"passed_time":19.92518872,"remaining_time":46.27145155,"test":[0.670509808]},
+{"learn":[0.6588837179],"iteration":602,"passed_time":19.95754179,"remaining_time":46.23662666,"test":[0.6705077789]},
+{"learn":[0.6588674101],"iteration":603,"passed_time":19.99116426,"remaining_time":46.20474388,"test":[0.6705212132]},
+{"learn":[0.6588406916],"iteration":604,"passed_time":20.01900069,"remaining_time":46.15951398,"test":[0.6705098442]},
+{"learn":[0.6588149945],"iteration":605,"passed_time":20.04735837,"remaining_time":46.11554053,"test":[0.6705061509]},
+{"learn":[0.6587866031],"iteration":606,"passed_time":20.07232044,"remaining_time":46.06382599,"test":[0.6705003071]},
+{"learn":[0.6587636648],"iteration":607,"passed_time":20.09871086,"remaining_time":46.01546959,"test":[0.6705045031]},
+{"learn":[0.6587502469],"iteration":608,"passed_time":20.12348304,"remaining_time":45.96348917,"test":[0.6705083194]},
+{"learn":[0.6587292784],"iteration":609,"passed_time":20.14920752,"remaining_time":45.91376797,"test":[0.6705329997]},
+{"learn":[0.6587104112],"iteration":610,"passed_time":20.17662353,"remaining_time":45.86797068,"test":[0.6705269987]},
+{"learn":[0.6586953782],"iteration":611,"passed_time":20.20202219,"remaining_time":45.81765818,"test":[0.6705315607]},
+{"learn":[0.6586641191],"iteration":612,"passed_time":20.23050051,"remaining_time":45.77439512,"test":[0.6705142835]},
+{"learn":[0.6586450136],"iteration":613,"passed_time":20.25381994,"remaining_time":45.71953492,"test":[0.6705165015]},
+{"learn":[0.6586136263],"iteration":614,"passed_time":20.28518384,"remaining_time":45.68289369,"test":[0.6705001061]},
+{"learn":[0.6585862768],"iteration":615,"passed_time":20.3078175,"remaining_time":45.62665489,"test":[0.6705013916]},
+{"learn":[0.6585585235],"iteration":616,"passed_time":20.33878033,"remaining_time":45.5891948,"test":[0.6705037253]},
+{"learn":[0.6585371631],"iteration":617,"passed_time":20.36122842,"remaining_time":45.53271469,"test":[0.67049647]},
+{"learn":[0.6585092632],"iteration":618,"passed_time":20.3943397,"remaining_time":45.50013429,"test":[0.6705005632]},
+{"learn":[0.6584914317],"iteration":619,"passed_time":20.42384285,"remaining_time":45.45952119,"test":[0.6704957943]},
+{"learn":[0.6584662432],"iteration":620,"passed_time":20.45411533,"remaining_time":45.42065225,"test":[0.6704955333]},
+{"learn":[0.6584454668],"iteration":621,"passed_time":20.488223,"remaining_time":45.39030754,"test":[0.6704961207]},
+{"learn":[0.6584249408],"iteration":622,"passed_time":20.51043528,"remaining_time":45.33365872,"test":[0.6704921459]},
+{"learn":[0.6583931228],"iteration":623,"passed_time":20.54384208,"remaining_time":45.30180561,"test":[0.6704751713]},
+{"learn":[0.6583660767],"iteration":624,"passed_time":20.56912557,"remaining_time":45.25207624,"test":[0.6704753101]},
+{"learn":[0.658354264],"iteration":625,"passed_time":20.59414123,"remaining_time":45.20183714,"test":[0.6704620888]},
+{"learn":[0.6583253625],"iteration":626,"passed_time":20.61901142,"remaining_time":45.15135993,"test":[0.6704604282]},
+{"learn":[0.6582968632],"iteration":627,"passed_time":20.6468542,"remaining_time":45.10745855,"test":[0.6704663192]},
+{"learn":[0.6582687399],"iteration":628,"passed_time":20.67583093,"remaining_time":45.06607981,"test":[0.6704680085]},
+{"learn":[0.658242535],"iteration":629,"passed_time":20.7010198,"remaining_time":45.01650336,"test":[0.670453228]},
+{"learn":[0.6582199874],"iteration":630,"passed_time":20.72783977,"remaining_time":44.97054302,"test":[0.6704577785]},
+{"learn":[0.6581918101],"iteration":631,"passed_time":20.75222724,"remaining_time":44.91937795,"test":[0.67046675]},
+{"learn":[0.6581735218],"iteration":632,"passed_time":20.78264004,"remaining_time":44.88130954,"test":[0.6704731863]},
+{"learn":[0.6581445869],"iteration":633,"passed_time":20.80459182,"remaining_time":44.82503538,"test":[0.6704811116]},
+{"learn":[0.6581202427],"iteration":634,"passed_time":20.83717209,"remaining_time":44.79171637,"test":[0.6704839644]},
+{"learn":[0.6580977862],"iteration":635,"passed_time":20.86231353,"remaining_time":44.74244599,"test":[0.6704854798]},
+{"learn":[0.6580724179],"iteration":636,"passed_time":20.89269601,"remaining_time":44.70446572,"test":[0.6704835837]},
+{"learn":[0.6580426322],"iteration":637,"passed_time":20.93117347,"remaining_time":44.68379039,"test":[0.6704736198]},
+{"learn":[0.6580111256],"iteration":638,"passed_time":20.96066949,"remaining_time":44.64392985,"test":[0.6704640242]},
+{"learn":[0.6579834747],"iteration":639,"passed_time":20.9941179,"remaining_time":44.61250055,"test":[0.670465663]},
+{"learn":[0.6579541367],"iteration":640,"passed_time":21.0224519,"remaining_time":44.57022174,"test":[0.6704646829]},
+{"learn":[0.6579254503],"iteration":641,"passed_time":21.0522529,"remaining_time":44.53108946,"test":[0.6704600961]},
+{"learn":[0.657898555],"iteration":642,"passed_time":21.08260618,"remaining_time":44.49315178,"test":[0.6704643207]},
+{"learn":[0.6578676875],"iteration":643,"passed_time":21.10716702,"remaining_time":44.44304112,"test":[0.6704600533]},
+{"learn":[0.6578324163],"iteration":644,"passed_time":21.13594828,"remaining_time":44.40187584,"test":[0.6704614691]},
+{"learn":[0.6578062223],"iteration":645,"passed_time":21.1601277,"remaining_time":44.35110357,"test":[0.6704728212]},
+{"learn":[0.6577760631],"iteration":646,"passed_time":21.18552999,"remaining_time":44.30297075,"test":[0.6704758731]},
+{"learn":[0.6577483474],"iteration":647,"passed_time":21.21048648,"remaining_time":44.25397797,"test":[0.6704833026]},
+{"learn":[0.6577249642],"iteration":648,"passed_time":21.23686209,"remaining_time":44.20801337,"test":[0.6704767664]},
+{"learn":[0.6576974966],"iteration":649,"passed_time":21.26287585,"remaining_time":44.16135753,"test":[0.6704702727]},
+{"learn":[0.657675114],"iteration":650,"passed_time":21.28806218,"remaining_time":44.11305051,"test":[0.6704671372]},
+{"learn":[0.6576447891],"iteration":651,"passed_time":21.31506267,"remaining_time":44.06856515,"test":[0.6704699936]},
+{"learn":[0.6576102356],"iteration":652,"passed_time":21.3435081,"remaining_time":44.02711394,"test":[0.6704587989]},
+{"learn":[0.6575793887],"iteration":653,"passed_time":21.37776713,"remaining_time":43.99766753,"test":[0.6704637668]},
+{"learn":[0.6575543309],"iteration":654,"passed_time":21.40301154,"remaining_time":43.94969545,"test":[0.6704653717]},
+{"learn":[0.6575340787],"iteration":655,"passed_time":21.44023109,"remaining_time":43.92632711,"test":[0.6704598273]},
+{"learn":[0.6575061464],"iteration":656,"passed_time":21.4778965,"remaining_time":43.903828,"test":[0.6704522865]},
+{"learn":[0.657476113],"iteration":657,"passed_time":21.50245582,"remaining_time":43.85455275,"test":[0.6704558586]},
+{"learn":[0.6574447014],"iteration":658,"passed_time":21.53379663,"remaining_time":43.81915217,"test":[0.6704466331]},
+{"learn":[0.6574247361],"iteration":659,"passed_time":21.55955041,"remaining_time":43.77242053,"test":[0.6704405886]},
+{"learn":[0.6574034983],"iteration":660,"passed_time":21.58626671,"remaining_time":43.72770215,"test":[0.6704463767]},
+{"learn":[0.6573783832],"iteration":661,"passed_time":21.61183918,"remaining_time":43.68072633,"test":[0.6704475216]},
+{"learn":[0.657357694],"iteration":662,"passed_time":21.6373217,"remaining_time":43.63363366,"test":[0.6704572386]},
+{"learn":[0.6573411592],"iteration":663,"passed_time":21.66283476,"remaining_time":43.58666753,"test":[0.6704658153]},
+{"learn":[0.6573118559],"iteration":664,"passed_time":21.68841321,"remaining_time":43.5398972,"test":[0.6704600945]},
+{"learn":[0.6572819076],"iteration":665,"passed_time":21.71420973,"remaining_time":43.4936273,"test":[0.6704561998]},
+{"learn":[0.6572430097],"iteration":666,"passed_time":21.74213421,"remaining_time":43.45167151,"test":[0.6704535154]},
+{"learn":[0.6572160391],"iteration":667,"passed_time":21.77174463,"remaining_time":43.41311953,"test":[0.6704413781]},
+{"learn":[0.6571931413],"iteration":668,"passed_time":21.81895309,"remaining_time":43.40960622,"test":[0.6704450013]},
+{"learn":[0.6571737099],"iteration":669,"passed_time":21.84627583,"remaining_time":43.36648784,"test":[0.6704422199]},
+{"learn":[0.6571532872],"iteration":670,"passed_time":21.88834724,"remaining_time":43.35262814,"test":[0.67044342]},
+{"learn":[0.6571208939],"iteration":671,"passed_time":21.93403139,"remaining_time":43.34582395,"test":[0.6704415341]},
+{"learn":[0.6570887673],"iteration":672,"passed_time":21.9714274,"remaining_time":43.32256191,"test":[0.6704439539]},
+{"learn":[0.6570633692],"iteration":673,"passed_time":22.01942449,"remaining_time":43.32011406,"test":[0.6704498197]},
+{"learn":[0.6570454361],"iteration":674,"passed_time":22.05319867,"remaining_time":43.2896122,"test":[0.6704452194]},
+{"learn":[0.6570231031],"iteration":675,"passed_time":22.09079747,"remaining_time":43.26659149,"test":[0.6704366524]},
+{"learn":[0.6570052089],"iteration":676,"passed_time":22.14192346,"remaining_time":43.26996269,"test":[0.6704427124]},
+{"learn":[0.6569855794],"iteration":677,"passed_time":22.17624471,"remaining_time":43.24040635,"test":[0.6704395579]},
+{"learn":[0.6569579709],"iteration":678,"passed_time":22.213192,"remaining_time":43.21594497,"test":[0.6704401246]},
+{"learn":[0.6569333354],"iteration":679,"passed_time":22.23966403,"remaining_time":43.17111253,"test":[0.6704415621]},
+{"learn":[0.6569069617],"iteration":680,"passed_time":22.27051241,"remaining_time":43.13481039,"test":[0.6704341343]},
+{"learn":[0.6568931857],"iteration":681,"passed_time":22.29625075,"remaining_time":43.08864881,"test":[0.6704369615]},
+{"learn":[0.6568734532],"iteration":682,"passed_time":22.32160622,"remaining_time":43.04180877,"test":[0.6704357425]},
+{"learn":[0.6568435196],"iteration":683,"passed_time":22.35059872,"remaining_time":43.00202911,"test":[0.6704294622]},
+{"learn":[0.6568108038],"iteration":684,"passed_time":22.37956576,"remaining_time":42.96223208,"test":[0.6704289794]},
+{"learn":[0.6567811374],"iteration":685,"passed_time":22.41993338,"remaining_time":42.94430389,"test":[0.6704272409]},
+{"learn":[0.6567467284],"iteration":686,"passed_time":22.45285267,"remaining_time":42.91207504,"test":[0.6704101162]},
+{"learn":[0.6567172734],"iteration":687,"passed_time":22.4848431,"remaining_time":42.8780729,"test":[0.6704069439]},
+{"learn":[0.6566967606],"iteration":688,"passed_time":22.51193834,"remaining_time":42.83476221,"test":[0.6704100747]},
+{"learn":[0.6566720128],"iteration":689,"passed_time":22.53798671,"remaining_time":42.78951101,"test":[0.6704122261]},
+{"learn":[0.6566441608],"iteration":690,"passed_time":22.57108439,"remaining_time":42.75766928,"test":[0.6704137826]},
+{"learn":[0.6566172287],"iteration":691,"passed_time":22.59836588,"remaining_time":42.7148303,"test":[0.6704207952]},
+{"learn":[0.6565952549],"iteration":692,"passed_time":22.62447507,"remaining_time":42.66982528,"test":[0.6704154834]},
+{"learn":[0.6565702687],"iteration":693,"passed_time":22.65349415,"remaining_time":42.63035067,"test":[0.6704253514]},
+{"learn":[0.6565392213],"iteration":694,"passed_time":22.68028991,"remaining_time":42.58673141,"test":[0.6704155636]},
+{"learn":[0.6565157938],"iteration":695,"passed_time":22.70844406,"remaining_time":42.54570555,"test":[0.6704141298]},
+{"learn":[0.6564902789],"iteration":696,"passed_time":22.73944116,"remaining_time":42.51003133,"test":[0.6704207635]},
+{"learn":[0.6564644734],"iteration":697,"passed_time":22.7613976,"remaining_time":42.45750671,"test":[0.6704268341]},
+{"learn":[0.6564349549],"iteration":698,"passed_time":22.79216825,"remaining_time":42.42147482,"test":[0.6704243126]},
+{"learn":[0.6564046572],"iteration":699,"passed_time":22.8167121,"remaining_time":42.37389389,"test":[0.6704235165]},
+{"learn":[0.6563744107],"iteration":700,"passed_time":22.84507296,"remaining_time":42.33345189,"test":[0.6704257736]},
+{"learn":[0.6563525063],"iteration":701,"passed_time":22.87088832,"remaining_time":42.28833766,"test":[0.6704247758]},
+{"learn":[0.6563189867],"iteration":702,"passed_time":22.90238907,"remaining_time":42.25376759,"test":[0.6704331799]},
+{"learn":[0.6562939062],"iteration":703,"passed_time":22.94246813,"remaining_time":42.23499815,"test":[0.6704252722]},
+{"learn":[0.6562739297],"iteration":704,"passed_time":22.97441688,"remaining_time":42.20123385,"test":[0.6704146644]},
+{"learn":[0.656256438],"iteration":705,"passed_time":23.00262167,"remaining_time":42.16061253,"test":[0.6704164122]},
+{"learn":[0.6562366475],"iteration":706,"passed_time":23.033437,"remaining_time":42.12480062,"test":[0.6704118954]},
+{"learn":[0.6562073096],"iteration":707,"passed_time":23.0545813,"remaining_time":42.07135458,"test":[0.6704043129]},
+{"learn":[0.6561864222],"iteration":708,"passed_time":23.08699831,"remaining_time":42.03852584,"test":[0.6703978198]},
+{"learn":[0.6561578826],"iteration":709,"passed_time":23.11590694,"remaining_time":41.99932387,"test":[0.6703935976]},
+{"learn":[0.6561208567],"iteration":710,"passed_time":23.14362702,"remaining_time":41.9579961,"test":[0.6703839683]},
+{"learn":[0.6560924703],"iteration":711,"passed_time":23.16985155,"remaining_time":41.91400112,"test":[0.6703843723]},
+{"learn":[0.6560656907],"iteration":712,"passed_time":23.19510285,"remaining_time":41.86829925,"test":[0.6703879502]},
+{"learn":[0.6560362588],"iteration":713,"passed_time":23.23034771,"remaining_time":41.84065429,"test":[0.6703895978]},
+{"learn":[0.6560124527],"iteration":714,"passed_time":23.25923754,"remaining_time":41.80156678,"test":[0.6703894359]},
+{"learn":[0.6559875055],"iteration":715,"passed_time":23.28703452,"remaining_time":41.76054794,"test":[0.6703928777]},
+{"learn":[0.6559547281],"iteration":716,"passed_time":23.31161175,"remaining_time":41.71380457,"test":[0.6703933128]},
+{"learn":[0.6559230866],"iteration":717,"passed_time":23.34170355,"remaining_time":41.67696929,"test":[0.6703844355]},
+{"learn":[0.6558924823],"iteration":718,"passed_time":23.37263658,"remaining_time":41.64165155,"test":[0.6703825151]},
+{"learn":[0.6558676469],"iteration":719,"passed_time":23.40571088,"remaining_time":41.61015268,"test":[0.6703983542]},
+{"learn":[0.6558459277],"iteration":720,"passed_time":23.4389719,"remaining_time":41.57898067,"test":[0.670399556]},
+{"learn":[0.6558149638],"iteration":721,"passed_time":23.48304084,"remaining_time":41.56693379,"test":[0.6703931808]},
+{"learn":[0.6557812248],"iteration":722,"passed_time":23.50734531,"remaining_time":41.5198893,"test":[0.6703886918]},
+{"learn":[0.6557546502],"iteration":723,"passed_time":23.54055835,"remaining_time":41.48860836,"test":[0.6703847574]},
+{"learn":[0.6557274948],"iteration":724,"passed_time":23.56652491,"remaining_time":41.44457829,"test":[0.6703885941]},
+{"learn":[0.6557044723],"iteration":725,"passed_time":23.59580183,"remaining_time":41.40640708,"test":[0.6703788615]},
+{"learn":[0.6556751811],"iteration":726,"passed_time":23.62334313,"remaining_time":41.36522119,"test":[0.6703799906]},
+{"learn":[0.6556539158],"iteration":727,"passed_time":23.64879831,"remaining_time":41.32042782,"test":[0.6703774518]},
+{"learn":[0.6556182915],"iteration":728,"passed_time":23.67755213,"remaining_time":41.28143862,"test":[0.6703783496]},
+{"learn":[0.6555977079],"iteration":729,"passed_time":23.70012944,"remaining_time":41.23173204,"test":[0.6703648854]},
+{"learn":[0.6555667903],"iteration":730,"passed_time":23.72866102,"remaining_time":41.19243615,"test":[0.6703716654]},
+{"learn":[0.6555394075],"iteration":731,"passed_time":23.75226732,"remaining_time":41.14463793,"test":[0.6703550938]},
+{"learn":[0.6555122742],"iteration":732,"passed_time":23.7844108,"remaining_time":41.11166233,"test":[0.6703467057]},
+{"learn":[0.6554814941],"iteration":733,"passed_time":23.80747563,"remaining_time":41.06303017,"test":[0.6703484503]},
+{"learn":[0.6554517373],"iteration":734,"passed_time":23.84023587,"remaining_time":41.03115425,"test":[0.6703549183]},
+{"learn":[0.655429552],"iteration":735,"passed_time":23.87042124,"remaining_time":40.99485387,"test":[0.6703501504]},
+{"learn":[0.655396579],"iteration":736,"passed_time":23.9087808,"remaining_time":40.97257823,"test":[0.6703672622]},
+{"learn":[0.6553735864],"iteration":737,"passed_time":23.94161529,"remaining_time":40.94081097,"test":[0.6703560249]},
+{"learn":[0.6553472597],"iteration":738,"passed_time":23.97478791,"remaining_time":40.90961779,"test":[0.6703547155]},
+{"learn":[0.6553252832],"iteration":739,"passed_time":24.00628859,"remaining_time":40.87557247,"test":[0.6703593236]},
+{"learn":[0.6552971659],"iteration":740,"passed_time":24.03623034,"remaining_time":40.83888528,"test":[0.6703606827]},
+{"learn":[0.6552763852],"iteration":741,"passed_time":24.06404686,"remaining_time":40.79861313,"test":[0.6703511404]},
+{"learn":[0.6552488203],"iteration":742,"passed_time":24.09270947,"remaining_time":40.75980593,"test":[0.6703431646]},
+{"learn":[0.65521229],"iteration":743,"passed_time":24.12724624,"remaining_time":40.73094258,"test":[0.6703475116]},
+{"learn":[0.6551949744],"iteration":744,"passed_time":24.15397955,"remaining_time":40.68891857,"test":[0.6703483634]},
+{"learn":[0.6551673797],"iteration":745,"passed_time":24.17955779,"remaining_time":40.64499392,"test":[0.6703475713]},
+{"learn":[0.6551421856],"iteration":746,"passed_time":24.20715317,"remaining_time":40.60450191,"test":[0.670360457]},
+{"learn":[0.6551255516],"iteration":747,"passed_time":24.23336836,"remaining_time":40.5617342,"test":[0.6703664352]},
+{"learn":[0.6551019608],"iteration":748,"passed_time":24.2614437,"remaining_time":40.52211759,"test":[0.6703617612]},
+{"learn":[0.6550758728],"iteration":749,"passed_time":24.29512083,"remaining_time":40.49186805,"test":[0.6703669926]},
+{"learn":[0.655051966],"iteration":750,"passed_time":24.31839238,"remaining_time":40.44430371,"test":[0.6703670837]},
+{"learn":[0.6550351058],"iteration":751,"passed_time":24.34977118,"remaining_time":40.41025856,"test":[0.6703706628]},
+{"learn":[0.6549998756],"iteration":752,"passed_time":24.3762114,"remaining_time":40.36804198,"test":[0.670369618]},
+{"learn":[0.6549721212],"iteration":753,"passed_time":24.40831154,"remaining_time":40.3352204,"test":[0.6703692351]},
+{"learn":[0.6549401744],"iteration":754,"passed_time":24.44267281,"remaining_time":40.30612934,"test":[0.6703624433]},
+{"learn":[0.6549207325],"iteration":755,"passed_time":24.47460721,"remaining_time":40.27303091,"test":[0.6703686285]},
+{"learn":[0.6548900891],"iteration":756,"passed_time":24.50826603,"remaining_time":40.24276708,"test":[0.6703598432]},
+{"learn":[0.6548682731],"iteration":757,"passed_time":24.54826542,"remaining_time":40.22288345,"test":[0.6703618766]},
+{"learn":[0.6548418938],"iteration":758,"passed_time":24.57546587,"remaining_time":40.18201996,"test":[0.6703694148]},
+{"learn":[0.6548234717],"iteration":759,"passed_time":24.60502723,"remaining_time":40.14504442,"test":[0.6703683652]},
+{"learn":[0.6547996833],"iteration":760,"passed_time":24.63261096,"remaining_time":40.10486856,"test":[0.6703604855]},
+{"learn":[0.6547726174],"iteration":761,"passed_time":24.66001655,"remaining_time":40.06443634,"test":[0.6703758987]},
+{"learn":[0.6547509314],"iteration":762,"passed_time":24.68929907,"remaining_time":40.02708119,"test":[0.6703773302]},
+{"learn":[0.6547168175],"iteration":763,"passed_time":24.71425118,"remaining_time":39.98274144,"test":[0.6703641028]},
+{"learn":[0.6546907846],"iteration":764,"passed_time":24.74589169,"remaining_time":39.94924999,"test":[0.6703649602]},
+{"learn":[0.6546671611],"iteration":765,"passed_time":24.76625006,"remaining_time":39.89758822,"test":[0.6703567811]},
+{"learn":[0.6546475893],"iteration":766,"passed_time":24.79734832,"remaining_time":39.86327312,"test":[0.6703544688]},
+{"learn":[0.6546206223],"iteration":767,"passed_time":24.82531049,"remaining_time":39.82393558,"test":[0.6703611821]},
+{"learn":[0.6545874193],"iteration":768,"passed_time":24.85435247,"remaining_time":39.78635616,"test":[0.6703527821]},
+{"learn":[0.6545620629],"iteration":769,"passed_time":24.88095966,"remaining_time":39.74490958,"test":[0.6703523616]},
+{"learn":[0.6545346297],"iteration":770,"passed_time":24.90935211,"remaining_time":39.70634726,"test":[0.6703616298]},
+{"learn":[0.6545172316],"iteration":771,"passed_time":24.94098876,"remaining_time":39.67297175,"test":[0.6703603551]},
+{"learn":[0.6544943049],"iteration":772,"passed_time":24.97035098,"remaining_time":39.6359905,"test":[0.6703675655]},
+{"learn":[0.6544632323],"iteration":773,"passed_time":25.00434422,"remaining_time":39.60636436,"test":[0.6703582411]},
+{"learn":[0.6544384097],"iteration":774,"passed_time":25.03067441,"remaining_time":39.56461439,"test":[0.6703581437]},
+{"learn":[0.6544084745],"iteration":775,"passed_time":25.05692652,"remaining_time":39.522781,"test":[0.6703551885]},
+{"learn":[0.6543765257],"iteration":776,"passed_time":25.08660163,"remaining_time":39.48637554,"test":[0.6703608491]},
+{"learn":[0.6543536123],"iteration":777,"passed_time":25.10764591,"remaining_time":39.43643098,"test":[0.6703674554]},
+{"learn":[0.6543303593],"iteration":778,"passed_time":25.13940138,"remaining_time":39.40334928,"test":[0.6703679619]},
+{"learn":[0.6543005831],"iteration":779,"passed_time":25.15916899,"remaining_time":39.35152074,"test":[0.6703701757]},
+{"learn":[0.6542678123],"iteration":780,"passed_time":25.18841105,"remaining_time":39.31456219,"test":[0.6703603462]},
+{"learn":[0.6542439303],"iteration":781,"passed_time":25.21444083,"remaining_time":39.27262012,"test":[0.670359801]},
+{"learn":[0.6542100401],"iteration":782,"passed_time":25.24017824,"remaining_time":39.23026426,"test":[0.6703523669]},
+{"learn":[0.6541836178],"iteration":783,"passed_time":25.2660091,"remaining_time":39.18809574,"test":[0.6703365674]},
+{"learn":[0.654158129],"iteration":784,"passed_time":25.28891553,"remaining_time":39.1414425,"test":[0.6703486118]},
+{"learn":[0.6541343464],"iteration":785,"passed_time":25.31589904,"remaining_time":39.10114686,"test":[0.6703450011]},
+{"learn":[0.6541092921],"iteration":786,"passed_time":25.34123581,"remaining_time":39.05834694,"test":[0.6703473135]},
+{"learn":[0.6540812254],"iteration":787,"passed_time":25.36728606,"remaining_time":39.01668871,"test":[0.670350998]},
+{"learn":[0.654060259],"iteration":788,"passed_time":25.39177931,"remaining_time":38.97268028,"test":[0.6703417767]},
+{"learn":[0.6540467253],"iteration":789,"passed_time":25.41712461,"remaining_time":38.9300263,"test":[0.6703349821]},
+{"learn":[0.6540306837],"iteration":790,"passed_time":25.44804125,"remaining_time":38.89593157,"test":[0.6703457717]},
+{"learn":[0.6540103667],"iteration":791,"passed_time":25.48249341,"remaining_time":38.86723743,"test":[0.6703506266]},
+{"learn":[0.6539821302],"iteration":792,"passed_time":25.51450657,"remaining_time":38.83481643,"test":[0.6703596395]},
+{"learn":[0.6539577914],"iteration":793,"passed_time":25.54216564,"remaining_time":38.79578307,"test":[0.6703799895]},
+{"learn":[0.653923724],"iteration":794,"passed_time":25.56982738,"remaining_time":38.75678238,"test":[0.6703687687]},
+{"learn":[0.6539086888],"iteration":795,"passed_time":25.59539769,"remaining_time":38.71464675,"test":[0.6703780675]},
+{"learn":[0.6538798424],"iteration":796,"passed_time":25.61874122,"remaining_time":38.66919157,"test":[0.670374835]},
+{"learn":[0.6538566996],"iteration":797,"passed_time":25.64394874,"remaining_time":38.62659947,"test":[0.6703831387]},
+{"learn":[0.6538290752],"iteration":798,"passed_time":25.66776244,"remaining_time":38.58195581,"test":[0.670377656]},
+{"learn":[0.6538051255],"iteration":799,"passed_time":25.69593415,"remaining_time":38.54390122,"test":[0.6703689741]},
+{"learn":[0.6537917354],"iteration":800,"passed_time":25.71651353,"remaining_time":38.49450652,"test":[0.6703709756]},
+{"learn":[0.6537684302],"iteration":801,"passed_time":25.74304126,"remaining_time":38.45406912,"test":[0.6703737517]},
+{"learn":[0.6537402991],"iteration":802,"passed_time":25.77084871,"remaining_time":38.41557398,"test":[0.6703818964]},
+{"learn":[0.6537165427],"iteration":803,"passed_time":25.79028824,"remaining_time":38.36465763,"test":[0.6703812173]},
+{"learn":[0.6536853601],"iteration":804,"passed_time":25.82203653,"remaining_time":38.3320915,"test":[0.6703960068]},
+{"learn":[0.6536681479],"iteration":805,"passed_time":25.84395064,"remaining_time":38.28495914,"test":[0.6703976729]},
+{"learn":[0.6536409101],"iteration":806,"passed_time":25.87390688,"remaining_time":38.24977808,"test":[0.6704024604]},
+{"learn":[0.6536120189],"iteration":807,"passed_time":25.89606204,"remaining_time":38.20310143,"test":[0.6704085008]},
+{"learn":[0.6535912493],"iteration":808,"passed_time":25.92585483,"remaining_time":38.16772942,"test":[0.6704076633]},
+{"learn":[0.6535617421],"iteration":809,"passed_time":25.95539059,"remaining_time":38.13199358,"test":[0.6704111719]},
+{"learn":[0.6535315174],"iteration":810,"passed_time":25.98822968,"remaining_time":38.10111601,"test":[0.6704220803]},
+{"learn":[0.6534972927],"iteration":811,"passed_time":26.02835773,"remaining_time":38.08089777,"test":[0.6704265011]},
+{"learn":[0.6534818476],"iteration":812,"passed_time":26.0558565,"remaining_time":38.04219146,"test":[0.6704251162]},
+{"learn":[0.6534498323],"iteration":813,"passed_time":26.08151817,"remaining_time":38.00083606,"test":[0.6704375472]},
+{"learn":[0.6534305025],"iteration":814,"passed_time":26.10848988,"remaining_time":37.96142393,"test":[0.6704319336]},
+{"learn":[0.6534081059],"iteration":815,"passed_time":26.13143346,"remaining_time":37.91619757,"test":[0.670437614]},
+{"learn":[0.6533765804],"iteration":816,"passed_time":26.15923661,"remaining_time":37.87806231,"test":[0.6704554331]},
+{"learn":[0.6533441549],"iteration":817,"passed_time":26.18805523,"remaining_time":37.84141966,"test":[0.6704603317]},
+{"learn":[0.6533053405],"iteration":818,"passed_time":26.2140726,"remaining_time":37.8007567,"test":[0.6704548042]},
+{"learn":[0.6532838469],"iteration":819,"passed_time":26.24289367,"remaining_time":37.76416405,"test":[0.6704502654]},
+{"learn":[0.6532604302],"iteration":820,"passed_time":26.27260776,"remaining_time":37.72887277,"test":[0.6704512072]},
+{"learn":[0.6532364412],"iteration":821,"passed_time":26.29880394,"remaining_time":37.68855358,"test":[0.6704433481]},
+{"learn":[0.6532100089],"iteration":822,"passed_time":26.32785215,"remaining_time":37.65234749,"test":[0.6704095112]},
+{"learn":[0.6531782515],"iteration":823,"passed_time":26.35925682,"remaining_time":37.61952188,"test":[0.6704086019]},
+{"learn":[0.6531449701],"iteration":824,"passed_time":26.38596096,"remaining_time":37.580005,"test":[0.6703987131]},
+{"learn":[0.653115452],"iteration":825,"passed_time":26.40854839,"remaining_time":37.53466805,"test":[0.6704019708]},
+{"learn":[0.6530787602],"iteration":826,"passed_time":26.44419918,"remaining_time":37.50791492,"test":[0.6704046556]},
+{"learn":[0.653052397],"iteration":827,"passed_time":26.47784276,"remaining_time":37.47829917,"test":[0.6704091961]},
+{"learn":[0.6530313579],"iteration":828,"passed_time":26.51701028,"remaining_time":37.45647652,"test":[0.6704103204]},
+{"learn":[0.6530010363],"iteration":829,"passed_time":26.53963123,"remaining_time":37.41128739,"test":[0.6704074257]},
+{"learn":[0.6529752146],"iteration":830,"passed_time":26.57362226,"remaining_time":37.38214732,"test":[0.6704115335]},
+{"learn":[0.652954801],"iteration":831,"passed_time":26.59767057,"remaining_time":37.33903754,"test":[0.6704041275]},
+{"learn":[0.6529330351],"iteration":832,"passed_time":26.62378941,"remaining_time":37.29887425,"test":[0.6704004556]},
+{"learn":[0.6528993709],"iteration":833,"passed_time":26.65024746,"remaining_time":37.25921887,"test":[0.6704037097]},
+{"learn":[0.6528665883],"iteration":834,"passed_time":26.67774911,"remaining_time":37.22105115,"test":[0.6704035477]},
+{"learn":[0.6528413041],"iteration":835,"passed_time":26.70473813,"remaining_time":37.1821952,"test":[0.6704025281]},
+{"learn":[0.6528217161],"iteration":836,"passed_time":26.72833235,"remaining_time":37.13865056,"test":[0.6704024549]},
+{"learn":[0.6527978782],"iteration":837,"passed_time":26.76384162,"remaining_time":37.11167537,"test":[0.670405721]},
+{"learn":[0.6527789461],"iteration":838,"passed_time":26.79137369,"remaining_time":37.07364106,"test":[0.6703983189]},
+{"learn":[0.6527432001],"iteration":839,"passed_time":26.82295602,"remaining_time":37.04122498,"test":[0.6704035256]},
+{"learn":[0.6527139767],"iteration":840,"passed_time":26.87217031,"remaining_time":37.03310985,"test":[0.6704047613]},
+{"learn":[0.6526857244],"iteration":841,"passed_time":26.92488006,"remaining_time":37.0297044,"test":[0.6704139617]},
+{"learn":[0.652657086],"iteration":842,"passed_time":26.98258041,"remaining_time":37.03303147,"test":[0.6704066193]},
+{"learn":[0.6526355016],"iteration":843,"passed_time":27.05424841,"remaining_time":37.05534497,"test":[0.670402892]},
+{"learn":[0.6526054936],"iteration":844,"passed_time":27.09765154,"remaining_time":37.03880181,"test":[0.6704081961]},
+{"learn":[0.6525793707],"iteration":845,"passed_time":27.12038959,"remaining_time":36.99400661,"test":[0.6704029862]},
+{"learn":[0.6525584692],"iteration":846,"passed_time":27.14691224,"remaining_time":36.95441537,"test":[0.6704014281]},
+{"learn":[0.6525279747],"iteration":847,"passed_time":27.18096334,"remaining_time":36.92508227,"test":[0.6704036115]},
+{"learn":[0.6525038765],"iteration":848,"passed_time":27.20686017,"remaining_time":36.88468322,"test":[0.6704016777]},
+{"learn":[0.6524849104],"iteration":849,"passed_time":27.23465701,"remaining_time":36.8468889,"test":[0.6704085392]},
+{"learn":[0.6524610603],"iteration":850,"passed_time":27.26094834,"remaining_time":36.80708536,"test":[0.6704042952]},
+{"learn":[0.6524357337],"iteration":851,"passed_time":27.28945577,"remaining_time":36.77029957,"test":[0.670394789]},
+{"learn":[0.6524082286],"iteration":852,"passed_time":27.31865398,"remaining_time":36.73446203,"test":[0.6703885644]},
+{"learn":[0.65238051],"iteration":853,"passed_time":27.34791322,"remaining_time":36.69872195,"test":[0.6703946813]},
+{"learn":[0.6523557826],"iteration":854,"passed_time":27.3865535,"remaining_time":36.67555995,"test":[0.6704042137]},
+{"learn":[0.6523391233],"iteration":855,"passed_time":27.41370907,"remaining_time":36.63701306,"test":[0.6704077517]},
+{"learn":[0.652325347],"iteration":856,"passed_time":27.43905921,"remaining_time":36.5960848,"test":[0.6704118698]},
+{"learn":[0.6522924958],"iteration":857,"passed_time":27.47159295,"remaining_time":36.56475425,"test":[0.6704114259]},
+{"learn":[0.6522623584],"iteration":858,"passed_time":27.50124299,"remaining_time":36.52959052,"test":[0.6704157567]},
+{"learn":[0.6522343891],"iteration":859,"passed_time":27.53509105,"remaining_time":36.50000442,"test":[0.6703837005]},
+{"learn":[0.6522094424],"iteration":860,"passed_time":27.57211091,"remaining_time":36.47460432,"test":[0.6703829482]},
+{"learn":[0.6521841478],"iteration":861,"passed_time":27.59555719,"remaining_time":36.43125764,"test":[0.6703818491]},
+{"learn":[0.6521657946],"iteration":862,"passed_time":27.6272049,"remaining_time":36.39876242,"test":[0.6703826129]},
+{"learn":[0.6521304278],"iteration":863,"passed_time":27.65462267,"remaining_time":36.36070759,"test":[0.6703834487]},
+{"learn":[0.6521045712],"iteration":864,"passed_time":27.68321566,"remaining_time":36.3242194,"test":[0.6703868275]},
+{"learn":[0.6520753696],"iteration":865,"passed_time":27.71151671,"remaining_time":36.28736714,"test":[0.6703853357]},
+{"learn":[0.6520519528],"iteration":866,"passed_time":27.73884016,"remaining_time":36.2492571,"test":[0.670450644]},
+{"learn":[0.6520216555],"iteration":867,"passed_time":27.76583897,"remaining_time":36.21074851,"test":[0.6704556991]},
+{"learn":[0.6519926935],"iteration":868,"passed_time":27.79498714,"remaining_time":36.17506382,"test":[0.6704535742]},
+{"learn":[0.6519734186],"iteration":869,"passed_time":27.82082723,"remaining_time":36.13509744,"test":[0.6704495915]}
+]}
@@ -0,0 +1,871 @@
+iter	Logloss
+0	0.692389481
+1	0.6916338586
+2	0.6910159214
+3	0.6903417151
+4	0.6896961461
+5	0.6890979366
+6	0.6884946167
+7	0.6879503686
+8	0.6874528094
+9	0.6869036785
+10	0.6863761921
+11	0.6859038678
+12	0.685410175
+13	0.6849483392
+14	0.6845417792
+15	0.6841038875
+16	0.6836957422
+17	0.6832947461
+18	0.6829014105
+19	0.6825264546
+20	0.6822106577
+21	0.6818649349
+22	0.6815467855
+23	0.6812293319
+24	0.6808837443
+25	0.6805816494
+26	0.6803209634
+27	0.6800350862
+28	0.6797703947
+29	0.6794926675
+30	0.6792251865
+31	0.6789670166
+32	0.678722402
+33	0.678476935
+34	0.6782297335
+35	0.6780226701
+36	0.6778291026
+37	0.6776045324
+38	0.6773969079
+39	0.6771819602
+40	0.6769816736
+41	0.6767984027
+42	0.6766201184
+43	0.6764394377
+44	0.6762698797
+45	0.6760974263
+46	0.6759245179
+47	0.6757673909
+48	0.6756172628
+49	0.675474531
+50	0.6753286933
+51	0.6751900513
+52	0.6750574835
+53	0.6749329567
+54	0.6748033265
+55	0.6746797823
+56	0.674535525
+57	0.6744256514
+58	0.674310819
+59	0.6741967947
+60	0.6740879654
+61	0.6739772476
+62	0.67388281
+63	0.6737789726
+64	0.6736812332
+65	0.6735930009
+66	0.6734947116
+67	0.6733961481
+68	0.6732990195
+69	0.6732133575
+70	0.673111539
+71	0.6730080451
+72	0.6729157861
+73	0.6728347949
+74	0.6727640693
+75	0.6726808811
+76	0.6726029645
+77	0.6725356026
+78	0.6724606887
+79	0.6723849561
+80	0.6723050519
+81	0.6722508802
+82	0.6721773904
+83	0.6721007598
+84	0.6720353564
+85	0.6719790902
+86	0.6719140024
+87	0.6718573633
+88	0.671795602
+89	0.6717369134
+90	0.6716711079
+91	0.6716070843
+92	0.6715517232
+93	0.6714957378
+94	0.6714364567
+95	0.6713881758
+96	0.6713336502
+97	0.6712700267
+98	0.6712154424
+99	0.6711600413
+100	0.6711060533
+101	0.6710494943
+102	0.6709936897
+103	0.6709472183
+104	0.6708914508
+105	0.6708388195
+106	0.6707885854
+107	0.6707454167
+108	0.6706973013
+109	0.6706577031
+110	0.67061108
+111	0.6705625485
+112	0.6705146484
+113	0.6704704423
+114	0.6704155922
+115	0.6703687117
+116	0.6703324232
+117	0.6702884624
+118	0.670253478
+119	0.6702140804
+120	0.6701682529
+121	0.6701320588
+122	0.6700939824
+123	0.6700655902
+124	0.6700190743
+125	0.6699792296
+126	0.6699379404
+127	0.669895454
+128	0.6698563938
+129	0.6698215571
+130	0.6697857067
+131	0.6697449303
+132	0.6697052425
+133	0.6696695553
+134	0.6696269265
+135	0.6695969271
+136	0.6695489786
+137	0.6695173859
+138	0.6694811164
+139	0.6694477439
+140	0.6694082161
+141	0.6693679185
+142	0.6693341916
+143	0.6692933159
+144	0.6692619696
+145	0.6692229289
+146	0.6691840164
+147	0.6691581406
+148	0.6691177196
+149	0.6690851126
+150	0.6690518144
+151	0.6690149711
+152	0.668993877
+153	0.6689596579
+154	0.6689372651
+155	0.6689003045
+156	0.6688680182
+157	0.6688348164
+158	0.6687947046
+159	0.6687605251
+160	0.668726253
+161	0.6686862718
+162	0.668663478
+163	0.6686399521
+164	0.6686058279
+165	0.6685761282
+166	0.6685469327
+167	0.6685157003
+168	0.6684805143
+169	0.6684485765
+170	0.6684144429
+171	0.6683849752
+172	0.6683568537
+173	0.6683266628
+174	0.6682937842
+175	0.6682657097
+176	0.6682301443
+177	0.6681995916
+178	0.6681658267
+179	0.6681422687
+180	0.6681216601
+181	0.6680899019
+182	0.6680676394
+183	0.6680413672
+184	0.6680088406
+185	0.6679873982
+186	0.6679663544
+187	0.6679417375
+188	0.6679100197
+189	0.667881208
+190	0.6678475427
+191	0.6678310341
+192	0.6678060257
+193	0.6677789336
+194	0.6677478773
+195	0.6677212408
+196	0.667704316
+197	0.6676819639
+198	0.6676554448
+199	0.6676318346
+200	0.6676074705
+201	0.6675849784
+202	0.6675631744
+203	0.6675397619
+204	0.6675169086
+205	0.6674864762
+206	0.6674670714
+207	0.6674375599
+208	0.6674148457
+209	0.6673974446
+210	0.6673812139
+211	0.6673515687
+212	0.6673197956
+213	0.6672900754
+214	0.6672550009
+215	0.6672271563
+216	0.667204521
+217	0.667181968
+218	0.6671640023
+219	0.66714351
+220	0.6671167156
+221	0.6670915937
+222	0.6670595279
+223	0.667033994
+224	0.6670008246
+225	0.6669858319
+226	0.6669553964
+227	0.6669274683
+228	0.666896348
+229	0.6668698686
+230	0.6668513411
+231	0.6668309985
+232	0.6668058585
+233	0.6667845908
+234	0.6667582863
+235	0.6667332943
+236	0.6667070085
+237	0.6666907315
+238	0.6666633028
+239	0.6666406707
+240	0.6666134624
+241	0.6665850522
+242	0.6665631193
+243	0.6665412643
+244	0.6665168385
+245	0.6664904845
+246	0.6664678274
+247	0.6664539777
+248	0.6664334121
+249	0.6664121724
+250	0.666392034
+251	0.666366899
+252	0.6663414098
+253	0.6663157816
+254	0.6662989799
+255	0.6662696102
+256	0.6662479711
+257	0.6662231874
+258	0.6661947927
+259	0.6661669951
+260	0.6661426137
+261	0.6661216749
+262	0.6660983123
+263	0.6660803402
+264	0.6660617842
+265	0.6660443878
+266	0.6660176079
+267	0.6659967546
+268	0.6659751467
+269	0.6659539329
+270	0.6659263951
+271	0.6659038921
+272	0.6658767418
+273	0.6658510507
+274	0.6658210119
+275	0.6657963011
+276	0.6657748552
+277	0.6657490013
+278	0.665732402
+279	0.6657118786
+280	0.665684467
+281	0.6656584634
+282	0.6656309991
+283	0.6656073482
+284	0.6655890957
+285	0.6655665563
+286	0.6655452454
+287	0.6655255286
+288	0.6655053548
+289	0.6654893396
+290	0.6654648912
+291	0.6654442759
+292	0.6654173127
+293	0.6653914518
+294	0.6653648946
+295	0.665344141
+296	0.6653140817
+297	0.665295365
+298	0.6652787488
+299	0.6652502991
+300	0.665231168
+301	0.6652136682
+302	0.6651903001
+303	0.6651697153
+304	0.6651525958
+305	0.6651322685
+306	0.6651113828
+307	0.6650886807
+308	0.6650622251
+309	0.6650429987
+310	0.665015513
+311	0.6650019022
+312	0.664979951
+313	0.6649549638
+314	0.6649340455
+315	0.6649162445
+316	0.6649048119
+317	0.6648796463
+318	0.6648605481
+319	0.6648429084
+320	0.6648238121
+321	0.6647969527
+322	0.6647854723
+323	0.6647589304
+324	0.6647429024
+325	0.6647237508
+326	0.6647059396
+327	0.664686288
+328	0.6646532527
+329	0.6646306438
+330	0.6646098516
+331	0.6645858284
+332	0.6645707188
+333	0.6645485788
+334	0.6645305696
+335	0.6645108881
+336	0.6644923286
+337	0.6644805222
+338	0.6644572776
+339	0.6644320741
+340	0.6644115048
+341	0.6643949013
+342	0.6643619789
+343	0.6643389502
+344	0.6643088915
+345	0.664286972
+346	0.664274149
+347	0.6642536926
+348	0.6642357634
+349	0.664207914
+350	0.6641853097
+351	0.6641654917
+352	0.664143804
+353	0.6641290647
+354	0.6641117244
+355	0.6640880219
+356	0.6640669415
+357	0.6640462999
+358	0.664030296
+359	0.6640028542
+360	0.6639813347
+361	0.6639597941
+362	0.6639429832
+363	0.6639222708
+364	0.6639065546
+365	0.6638823236
+366	0.6638648195
+367	0.6638436235
+368	0.6638208732
+369	0.6637956357
+370	0.6637718453
+371	0.663756918
+372	0.6637353525
+373	0.6637143112
+374	0.6636956547
+375	0.663680995
+376	0.66366728
+377	0.6636487567
+378	0.6636266904
+379	0.6636116064
+380	0.6635902746
+381	0.6635654896
+382	0.6635393029
+383	0.6635171734
+384	0.663500789
+385	0.663477743
+386	0.6634584806
+387	0.6634337499
+388	0.6634135584
+389	0.6633868455
+390	0.6633755323
+391	0.663356103
+392	0.6633337631
+393	0.663319422
+394	0.6632911566
+395	0.6632687875
+396	0.6632431997
+397	0.6632189331
+398	0.663201035
+399	0.6631898553
+400	0.6631712482
+401	0.663143025
+402	0.663121538
+403	0.6631087792
+404	0.6630859067
+405	0.663066483
+406	0.6630443652
+407	0.6630250376
+408	0.6630007822
+409	0.6629768728
+410	0.6629528093
+411	0.6629260936
+412	0.6629102182
+413	0.6628863488
+414	0.6628648972
+415	0.6628454339
+416	0.6628200274
+417	0.6627942591
+418	0.6627744647
+419	0.662765485
+420	0.6627503257
+421	0.6627323029
+422	0.6627111509
+423	0.6626785863
+424	0.6626576561
+425	0.6626363113
+426	0.6626181065
+427	0.66259794
+428	0.6625765658
+429	0.6625526572
+430	0.66253135
+431	0.6625035695
+432	0.662480212
+433	0.6624611632
+434	0.6624332625
+435	0.6624120584
+436	0.6623941719
+437	0.6623766304
+438	0.6623623329
+439	0.6623442925
+440	0.6623212715
+441	0.6623025941
+442	0.6622749791
+443	0.6622534499
+444	0.6622305473
+445	0.6622059333
+446	0.6621871707
+447	0.6621638454
+448	0.6621511296
+449	0.6621349978
+450	0.6621120424
+451	0.6620958271
+452	0.6620793528
+453	0.6620572713
+454	0.6620395025
+455	0.6620188044
+456	0.6620017347
+457	0.6619811454
+458	0.6619695569
+459	0.661952377
+460	0.6619237442
+461	0.6619089407
+462	0.6618886168
+463	0.6618831383
+464	0.6618690774
+465	0.661845878
+466	0.6618290213
+467	0.6618050064
+468	0.6617832833
+469	0.6617652311
+470	0.6617443144
+471	0.6617202619
+472	0.6617005831
+473	0.6616824419
+474	0.6616538226
+475	0.6616314155
+476	0.6616127861
+477	0.6616029072
+478	0.6615843751
+479	0.661563216
+480	0.6615432257
+481	0.6615263324
+482	0.6615033259
+483	0.661484293
+484	0.6614678231
+485	0.6614463024
+486	0.6614155436
+487	0.6613958945
+488	0.661380611
+489	0.6613677802
+490	0.6613530086
+491	0.6613248211
+492	0.6613059359
+493	0.6612729965
+494	0.6612624948
+495	0.6612401679
+496	0.6612191637
+497	0.6611912219
+498	0.6611773017
+499	0.6611638216
+500	0.6611450533
+501	0.6611179111
+502	0.6610959069
+503	0.6610728788
+504	0.6610436668
+505	0.6610188976
+506	0.6610030555
+507	0.6609831174
+508	0.6609586562
+509	0.660935882
+510	0.6609202024
+511	0.6609011137
+512	0.6608726737
+513	0.6608608849
+514	0.6608387256
+515	0.6608136063
+516	0.6607946343
+517	0.6607703935
+518	0.6607509625
+519	0.6607238109
+520	0.6606999858
+521	0.6606813873
+522	0.6606610372
+523	0.660638456
+524	0.6606156483
+525	0.6605968623
+526	0.6605735776
+527	0.6605517294
+528	0.6605309239
+529	0.6605086434
+530	0.6604803349
+531	0.6604566326
+532	0.6604430839
+533	0.6604273738
+534	0.6604048016
+535	0.6603845173
+536	0.6603669212
+537	0.6603488983
+538	0.6603176881
+539	0.6602953862
+540	0.6602672025
+541	0.6602568636
+542	0.660235705
+543	0.6602152295
+544	0.6601897709
+545	0.6601683731
+546	0.6601472267
+547	0.6601262337
+548	0.6601119991
+549	0.6600869973
+550	0.6600667497
+551	0.6600397508
+552	0.660016863
+553	0.6599933158
+554	0.6599632649
+555	0.6599446007
+556	0.6599138126
+557	0.6598965504
+558	0.6598785723
+559	0.659860838
+560	0.6598408724
+561	0.6598244857
+562	0.6598082469
+563	0.6597851673
+564	0.6597683521
+565	0.6597479006
+566	0.6597310938
+567	0.6597096581
+568	0.6596862311
+569	0.6596574779
+570	0.6596385418
+571	0.6596189903
+572	0.65959275
+573	0.6595730662
+574	0.6595566809
+575	0.6595365076
+576	0.6595163446
+577	0.6594816637
+578	0.6594570142
+579	0.6594353055
+580	0.6594162362
+581	0.659395036
+582	0.6593798831
+583	0.6593556719
+584	0.6593292627
+585	0.6592976737
+586	0.6592754841
+587	0.6592510441
+588	0.6592290326
+589	0.6592097404
+590	0.6591876204
+591	0.6591705995
+592	0.6591456195
+593	0.6591107122
+594	0.6590819533
+595	0.6590551327
+596	0.6590373916
+597	0.6590177149
+598	0.6589946095
+599	0.6589697628
+600	0.6589442269
+601	0.6589182437
+602	0.6588837179
+603	0.6588674101
+604	0.6588406916
+605	0.6588149945
+606	0.6587866031
+607	0.6587636648
+608	0.6587502469
+609	0.6587292784
+610	0.6587104112
+611	0.6586953782
+612	0.6586641191
+613	0.6586450136
+614	0.6586136263
+615	0.6585862768
+616	0.6585585235
+617	0.6585371631
+618	0.6585092632
+619	0.6584914317
+620	0.6584662432
+621	0.6584454668
+622	0.6584249408
+623	0.6583931228
+624	0.6583660767
+625	0.658354264
+626	0.6583253625
+627	0.6582968632
+628	0.6582687399
+629	0.658242535
+630	0.6582199874
+631	0.6581918101
+632	0.6581735218
+633	0.6581445869
+634	0.6581202427
+635	0.6580977862
+636	0.6580724179
+637	0.6580426322
+638	0.6580111256
+639	0.6579834747
+640	0.6579541367
+641	0.6579254503
+642	0.657898555
+643	0.6578676875
+644	0.6578324163
+645	0.6578062223
+646	0.6577760631
+647	0.6577483474
+648	0.6577249642
+649	0.6576974966
+650	0.657675114
+651	0.6576447891
+652	0.6576102356
+653	0.6575793887
+654	0.6575543309
+655	0.6575340787
+656	0.6575061464
+657	0.657476113
+658	0.6574447014
+659	0.6574247361
+660	0.6574034983
+661	0.6573783832
+662	0.657357694
+663	0.6573411592
+664	0.6573118559
+665	0.6572819076
+666	0.6572430097
+667	0.6572160391
+668	0.6571931413
+669	0.6571737099
+670	0.6571532872
+671	0.6571208939
+672	0.6570887673
+673	0.6570633692
+674	0.6570454361
+675	0.6570231031
+676	0.6570052089
+677	0.6569855794
+678	0.6569579709
+679	0.6569333354
+680	0.6569069617
+681	0.6568931857
+682	0.6568734532
+683	0.6568435196
+684	0.6568108038
+685	0.6567811374
+686	0.6567467284
+687	0.6567172734
+688	0.6566967606
+689	0.6566720128
+690	0.6566441608
+691	0.6566172287
+692	0.6565952549
+693	0.6565702687
+694	0.6565392213
+695	0.6565157938
+696	0.6564902789
+697	0.6564644734
+698	0.6564349549
+699	0.6564046572
+700	0.6563744107
+701	0.6563525063
+702	0.6563189867
+703	0.6562939062
+704	0.6562739297
+705	0.656256438
+706	0.6562366475
+707	0.6562073096
+708	0.6561864222
+709	0.6561578826
+710	0.6561208567
+711	0.6560924703
+712	0.6560656907
+713	0.6560362588
+714	0.6560124527
+715	0.6559875055
+716	0.6559547281
+717	0.6559230866
+718	0.6558924823
+719	0.6558676469
+720	0.6558459277
+721	0.6558149638
+722	0.6557812248
+723	0.6557546502
+724	0.6557274948
+725	0.6557044723
+726	0.6556751811
+727	0.6556539158
+728	0.6556182915
+729	0.6555977079
+730	0.6555667903
+731	0.6555394075
+732	0.6555122742
+733	0.6554814941
+734	0.6554517373
+735	0.655429552
+736	0.655396579
+737	0.6553735864
+738	0.6553472597
+739	0.6553252832
+740	0.6552971659
+741	0.6552763852
+742	0.6552488203
+743	0.65521229
+744	0.6551949744
+745	0.6551673797
+746	0.6551421856
+747	0.6551255516
+748	0.6551019608
+749	0.6550758728
+750	0.655051966
+751	0.6550351058
+752	0.6549998756
+753	0.6549721212
+754	0.6549401744
+755	0.6549207325
+756	0.6548900891
+757	0.6548682731
+758	0.6548418938
+759	0.6548234717
+760	0.6547996833
+761	0.6547726174
+762	0.6547509314
+763	0.6547168175
+764	0.6546907846
+765	0.6546671611
+766	0.6546475893
+767	0.6546206223
+768	0.6545874193
+769	0.6545620629
+770	0.6545346297
+771	0.6545172316
+772	0.6544943049
+773	0.6544632323
+774	0.6544384097
+775	0.6544084745
+776	0.6543765257
+777	0.6543536123
+778	0.6543303593
+779	0.6543005831
+780	0.6542678123
+781	0.6542439303
+782	0.6542100401
+783	0.6541836178
+784	0.654158129
+785	0.6541343464
+786	0.6541092921
+787	0.6540812254
+788	0.654060259
+789	0.6540467253
+790	0.6540306837
+791	0.6540103667
+792	0.6539821302
+793	0.6539577914
+794	0.653923724
+795	0.6539086888
+796	0.6538798424
+797	0.6538566996
+798	0.6538290752
+799	0.6538051255
+800	0.6537917354
+801	0.6537684302
+802	0.6537402991
+803	0.6537165427
+804	0.6536853601
+805	0.6536681479
+806	0.6536409101
+807	0.6536120189
+808	0.6535912493
+809	0.6535617421
+810	0.6535315174
+811	0.6534972927
+812	0.6534818476
+813	0.6534498323
+814	0.6534305025
+815	0.6534081059
+816	0.6533765804
+817	0.6533441549
+818	0.6533053405
+819	0.6532838469
+820	0.6532604302
+821	0.6532364412
+822	0.6532100089
+823	0.6531782515
+824	0.6531449701
+825	0.653115452
+826	0.6530787602
+827	0.653052397
+828	0.6530313579
+829	0.6530010363
+830	0.6529752146
+831	0.652954801
+832	0.6529330351
+833	0.6528993709
+834	0.6528665883
+835	0.6528413041
+836	0.6528217161
+837	0.6527978782
+838	0.6527789461
+839	0.6527432001
+840	0.6527139767
+841	0.6526857244
+842	0.652657086
+843	0.6526355016
+844	0.6526054936
+845	0.6525793707
+846	0.6525584692
+847	0.6525279747
+848	0.6525038765
+849	0.6524849104
+850	0.6524610603
+851	0.6524357337
+852	0.6524082286
+853	0.65238051
+854	0.6523557826
+855	0.6523391233
+856	0.652325347
+857	0.6522924958
+858	0.6522623584
+859	0.6522343891
+860	0.6522094424
+861	0.6521841478
+862	0.6521657946
+863	0.6521304278
+864	0.6521045712
+865	0.6520753696
+866	0.6520519528
+867	0.6520216555
+868	0.6519926935
+869	0.6519734186
@@ -0,0 +1,871 @@
+iter	Passed	Remaining
+0	46	93548
+1	83	83419
+2	132	88415
+3	162	81250
+4	196	78573
+5	230	76747
+6	269	76701
+7	319	79674
+8	364	80653
+9	411	81918
+10	456	82497
+11	491	81432
+12	522	79809
+13	555	78774
+14	595	78777
+15	630	78123
+16	662	77290
+17	700	77124
+18	730	76120
+19	764	75651
+20	804	75774
+21	835	75128
+22	886	76169
+23	920	75764
+24	960	75853
+25	989	75130
+26	1025	74941
+27	1060	74714
+28	1104	75079
+29	1141	74976
+30	1180	74975
+31	1213	74640
+32	1245	74260
+33	1287	74434
+34	1327	74528
+35	1376	75071
+36	1427	75741
+37	1468	75804
+38	1508	75857
+39	1549	75922
+40	1586	75781
+41	1621	75590
+42	1663	75705
+43	1701	75621
+44	1739	75591
+45	1776	75460
+46	1819	75616
+47	1869	76025
+48	1916	76288
+49	1953	76191
+50	1993	76197
+51	2038	76381
+52	2080	76420
+53	2158	77788
+54	2220	78529
+55	2286	79390
+56	2328	79372
+57	2367	79254
+58	2409	79257
+59	2444	79049
+60	2484	78985
+61	2521	78820
+62	2554	78528
+63	2593	78466
+64	2623	78111
+65	2660	77969
+66	2695	77776
+67	2725	77446
+68	2761	77291
+69	2791	76975
+70	2824	76739
+71	2861	76611
+72	2897	76476
+73	2935	76408
+74	3040	78027
+75	3097	78411
+76	3152	78741
+77	3216	79248
+78	3256	79195
+79	3305	79336
+80	3348	79320
+81	3381	79089
+82	3416	78911
+83	3480	79399
+84	3535	79649
+85	3581	79716
+86	3612	79428
+87	3644	79185
+88	3678	78975
+89	3712	78785
+90	3743	78531
+91	3775	78297
+92	3806	78047
+93	3837	77821
+94	3871	77629
+95	3913	77618
+96	3945	77403
+97	3989	77433
+98	4020	77204
+99	4053	77020
+100	4084	76789
+101	4116	76597
+102	4148	76401
+103	4176	76141
+104	4202	75845
+105	4232	75634
+106	4261	75390
+107	4290	75168
+108	4324	75018
+109	4351	74766
+110	4386	74648
+111	4424	74577
+112	4458	74455
+113	4497	74400
+114	4533	74307
+115	4564	74136
+116	4596	73981
+117	4628	73818
+118	4668	73786
+119	4692	73509
+120	4723	73354
+121	4756	73220
+122	4788	73065
+123	4815	72854
+124	4843	72647
+125	4875	72514
+126	4916	72515
+127	4952	72436
+128	4991	72397
+129	5028	72327
+130	5059	72180
+131	5096	72116
+132	5125	71946
+133	5156	71804
+134	5190	71704
+135	5221	71564
+136	5251	71407
+137	5274	71165
+138	5309	71084
+139	5344	71008
+140	5377	70902
+141	5416	70866
+142	5452	70803
+143	5490	70760
+144	5521	70641
+145	5553	70522
+146	5582	70365
+147	5611	70217
+148	5636	70026
+149	5673	69975
+150	5706	69874
+151	5738	69764
+152	5765	69605
+153	5795	69471
+154	5817	69246
+155	5853	69191
+156	5888	69122
+157	5924	69070
+158	5964	69061
+159	5996	68963
+160	6022	68789
+161	6050	68650
+162	6079	68510
+163	6108	68385
+164	6140	68292
+165	6169	68162
+166	6202	68074
+167	6231	67953
+168	6263	67858
+169	6295	67764
+170	6325	67656
+171	6356	67561
+172	6395	67545
+173	6437	67554
+174	6472	67495
+175	6503	67395
+176	6533	67291
+177	6562	67174
+178	6590	67049
+179	6624	66982
+180	6655	66882
+181	6687	66804
+182	6718	66703
+183	6751	66632
+184	6784	66559
+185	6810	66424
+186	6832	66246
+187	6867	66187
+188	6918	66294
+189	6969	66393
+190	7018	66470
+191	7074	66614
+192	7117	66635
+193	7191	66943
+194	7242	67036
+195	7282	67027
+196	7317	66967
+197	7351	66903
+198	7389	66879
+199	7432	66896
+200	7471	66869
+201	7506	66814
+202	7540	66752
+203	7568	66628
+204	7605	66596
+205	7638	66519
+206	7665	66397
+207	7700	66340
+208	7734	66276
+209	7766	66197
+210	7796	66106
+211	7831	66053
+212	7871	66037
+213	7910	66016
+214	7951	66014
+215	7989	65983
+216	8025	65946
+217	8058	65872
+218	8087	65768
+219	8112	65638
+220	8148	65594
+221	8197	65655
+222	8239	65655
+223	8268	65556
+224	8298	65466
+225	8327	65366
+226	8357	65278
+227	8384	65167
+228	8418	65103
+229	8453	65058
+230	8490	65020
+231	8523	64958
+232	8550	64848
+233	8575	64718
+234	8607	64648
+235	8635	64545
+236	8660	64426
+237	8691	64345
+238	8719	64250
+239	8746	64137
+240	8773	64038
+241	8803	63951
+242	8833	63873
+243	8862	63779
+244	8892	63698
+245	8932	63688
+246	8962	63611
+247	8991	63521
+248	9021	63442
+249	9051	63358
+250	9085	63306
+251	9110	63193
+252	9137	63093
+253	9174	63066
+254	9196	62935
+255	9238	62934
+256	9267	62855
+257	9297	62776
+258	9324	62681
+259	9357	62625
+260	9388	62552
+261	9427	62536
+262	9461	62491
+263	9496	62443
+264	9524	62356
+265	9553	62278
+266	9590	62247
+267	9620	62172
+268	9645	62071
+269	9682	62040
+270	9711	61962
+271	9739	61872
+272	9768	61797
+273	9804	61761
+274	9848	61777
+275	9886	61755
+276	9925	61740
+277	9965	61728
+278	9995	61656
+279	10022	61564
+280	10055	61516
+281	10080	61410
+282	10111	61344
+283	10147	61311
+284	10175	61230
+285	10202	61141
+286	10234	61084
+287	10264	61018
+288	10299	60977
+289	10323	60874
+290	10353	60804
+291	10394	60803
+292	10431	60773
+293	10471	60763
+294	10503	60707
+295	10534	60645
+296	10576	60646
+297	10612	60612
+298	10639	60525
+299	10668	60453
+300	10702	60411
+301	10729	60326
+302	10764	60290
+303	10801	60263
+304	10829	60182
+305	10857	60108
+306	10892	60067
+307	10930	60047
+308	10972	60045
+309	11002	59983
+310	11030	59902
+311	11058	59828
+312	11092	59788
+313	11117	59696
+314	11149	59641
+315	11187	59617
+316	11211	59525
+317	11243	59468
+318	11274	59413
+319	11304	59346
+320	11334	59287
+321	11362	59209
+322	11394	59158
+323	11436	59158
+324	11477	59153
+325	11513	59122
+326	11547	59081
+327	11572	58991
+328	11607	58956
+329	11637	58894
+330	11668	58833
+331	11700	58785
+332	11724	58694
+333	11757	58648
+334	11780	58550
+335	11815	58515
+336	11844	58451
+337	11869	58364
+338	11905	58335
+339	11941	58302
+340	11986	58315
+341	12020	58274
+342	12066	58292
+343	12122	58358
+344	12177	58415
+345	12221	58422
+346	12264	58423
+347	12300	58394
+348	12324	58304
+349	12354	58243
+350	12401	58262
+351	12438	58232
+352	12479	58228
+353	12512	58179
+354	12541	58116
+355	12569	58044
+356	12597	57977
+357	12628	57920
+358	12653	57839
+359	12682	57775
+360	12720	57752
+361	12744	57666
+362	12770	57592
+363	12811	57583
+364	12841	57522
+365	12870	57460
+366	12897	57386
+367	12938	57378
+368	12974	57347
+369	13009	57313
+370	13038	57249
+371	13078	57235
+372	13117	57216
+373	13147	57159
+374	13181	57118
+375	13205	57036
+376	13235	56979
+377	13274	56960
+378	13306	56911
+379	13333	56841
+380	13366	56798
+381	13396	56741
+382	13421	56666
+383	13467	56674
+384	13508	56664
+385	13540	56616
+386	13569	56559
+387	13598	56496
+388	13627	56438
+389	13656	56376
+390	13685	56317
+391	13717	56271
+392	13750	56227
+393	13771	56135
+394	13804	56090
+395	13825	55999
+396	13858	55957
+397	13888	55904
+398	13917	55843
+399	13953	55812
+400	13994	55802
+401	14025	55752
+402	14048	55670
+403	14076	55607
+404	14105	55551
+405	14142	55526
+406	14182	55511
+407	14214	55464
+408	14240	55394
+409	14267	55328
+410	14299	55284
+411	14324	55213
+412	14351	55146
+413	14379	55086
+414	14410	55036
+415	14451	55025
+416	14484	54984
+417	14513	54929
+418	14536	54851
+419	14565	54793
+420	14587	54710
+421	14615	54650
+422	14642	54588
+423	14666	54515
+424	14690	54441
+425	14719	54384
+426	14739	54297
+427	14772	54257
+428	14790	54164
+429	14824	54125
+430	14844	54039
+431	14876	53995
+432	14906	53946
+433	14938	53902
+434	14980	53894
+435	15006	53829
+436	15033	53770
+437	15059	53706
+438	15085	53639
+439	15110	53574
+440	15134	53503
+441	15160	53438
+442	15184	53369
+443	15211	53308
+444	15234	53236
+445	15266	53193
+446	15287	53114
+447	15316	53059
+448	15336	52978
+449	15366	52929
+450	15393	52870
+451	15429	52843
+452	15469	52828
+453	15490	52748
+454	15523	52712
+455	15550	52653
+456	15577	52594
+457	15604	52536
+458	15630	52476
+459	15656	52414
+460	15682	52353
+461	15711	52304
+462	15736	52238
+463	15765	52188
+464	15786	52112
+465	15817	52068
+466	15839	51996
+467	15873	51961
+468	15903	51916
+469	15935	51873
+470	15969	51840
+471	15994	51779
+472	16022	51726
+473	16047	51663
+474	16073	51605
+475	16099	51546
+476	16128	51495
+477	16152	51431
+478	16176	51367
+479	16205	51317
+480	16228	51250
+481	16255	51194
+482	16277	51123
+483	16305	51071
+484	16328	51005
+485	16362	50973
+486	16392	50928
+487	16426	50894
+488	16459	50860
+489	16480	50787
+490	16510	50743
+491	16530	50668
+492	16561	50625
+493	16585	50562
+494	16613	50510
+495	16638	50453
+496	16663	50393
+497	16690	50339
+498	16716	50282
+499	16740	50222
+500	16773	50186
+501	16802	50139
+502	16836	50107
+503	16873	50085
+504	16921	50094
+505	16989	50163
+506	17038	50173
+507	17069	50132
+508	17110	50121
+509	17145	50091
+510	17190	50091
+511	17219	50044
+512	17247	49994
+513	17271	49932
+514	17298	49878
+515	17343	49878
+516	17373	49836
+517	17417	49831
+518	17460	49823
+519	17490	49781
+520	17518	49731
+521	17546	49680
+522	17571	49622
+523	17600	49577
+524	17625	49520
+525	17655	49474
+526	17679	49414
+527	17707	49366
+528	17729	49300
+529	17758	49254
+530	17781	49191
+531	17808	49141
+532	17829	49071
+533	17862	49038
+534	17905	49031
+535	18028	49241
+536	18072	49236
+537	18106	49203
+538	18135	49157
+539	18165	49114
+540	18200	49083
+541	18223	49022
+542	18254	48980
+543	18280	48927
+544	18307	48876
+545	18338	48834
+546	18367	48790
+547	18411	48783
+548	18444	48747
+549	18470	48693
+550	18503	48660
+551	18531	48611
+552	18557	48558
+553	18584	48508
+554	18625	48493
+555	18650	48436
+556	18677	48388
+557	18703	48333
+558	18729	48282
+559	18756	48231
+560	18781	48176
+561	18808	48126
+562	18834	48074
+563	18869	48043
+564	18902	48008
+565	18930	47960
+566	18958	47914
+567	18983	47859
+568	19016	47824
+569	19037	47761
+570	19068	47720
+571	19090	47660
+572	19111	47595
+573	19141	47553
+574	19164	47494
+575	19196	47458
+576	19217	47393
+577	19249	47358
+578	19274	47303
+579	19298	47247
+580	19324	47195
+581	19357	47162
+582	19391	47130
+583	19427	47103
+584	19460	47070
+585	19483	47012
+586	19511	46967
+587	19542	46929
+588	19564	46867
+589	19597	46833
+590	19621	46779
+591	19647	46729
+592	19670	46672
+593	19699	46627
+594	19726	46582
+595	19753	46532
+596	19778	46480
+597	19803	46429
+598	19830	46381
+599	19857	46335
+600	19896	46313
+601	19925	46271
+602	19957	46236
+603	19991	46204
+604	20019	46159
+605	20047	46115
+606	20072	46063
+607	20098	46015
+608	20123	45963
+609	20149	45913
+610	20176	45867
+611	20202	45817
+612	20230	45774
+613	20253	45719
+614	20285	45682
+615	20307	45626
+616	20338	45589
+617	20361	45532
+618	20394	45500
+619	20423	45459
+620	20454	45420
+621	20488	45390
+622	20510	45333
+623	20543	45301
+624	20569	45252
+625	20594	45201
+626	20619	45151
+627	20646	45107
+628	20675	45066
+629	20701	45016
+630	20727	44970
+631	20752	44919
+632	20782	44881
+633	20804	44825
+634	20837	44791
+635	20862	44742
+636	20892	44704
+637	20931	44683
+638	20960	44643
+639	20994	44612
+640	21022	44570
+641	21052	44531
+642	21082	44493
+643	21107	44443
+644	21135	44401
+645	21160	44351
+646	21185	44302
+647	21210	44253
+648	21236	44208
+649	21262	44161
+650	21288	44113
+651	21315	44068
+652	21343	44027
+653	21377	43997
+654	21403	43949
+655	21440	43926
+656	21477	43903
+657	21502	43854
+658	21533	43819
+659	21559	43772
+660	21586	43727
+661	21611	43680
+662	21637	43633
+663	21662	43586
+664	21688	43539
+665	21714	43493
+666	21742	43451
+667	21771	43413
+668	21818	43409
+669	21846	43366
+670	21888	43352
+671	21934	43345
+672	21971	43322
+673	22019	43320
+674	22053	43289
+675	22090	43266
+676	22141	43269
+677	22176	43240
+678	22213	43215
+679	22239	43171
+680	22270	43134
+681	22296	43088
+682	22321	43041
+683	22350	43002
+684	22379	42962
+685	22419	42944
+686	22452	42912
+687	22484	42878
+688	22511	42834
+689	22537	42789
+690	22571	42757
+691	22598	42714
+692	22624	42669
+693	22653	42630
+694	22680	42586
+695	22708	42545
+696	22739	42510
+697	22761	42457
+698	22792	42421
+699	22816	42373
+700	22845	42333
+701	22870	42288
+702	22902	42253
+703	22942	42234
+704	22974	42201
+705	23002	42160
+706	23033	42124
+707	23054	42071
+708	23086	42038
+709	23115	41999
+710	23143	41957
+711	23169	41914
+712	23195	41868
+713	23230	41840
+714	23259	41801
+715	23287	41760
+716	23311	41713
+717	23341	41676
+718	23372	41641
+719	23405	41610
+720	23438	41578
+721	23483	41566
+722	23507	41519
+723	23540	41488
+724	23566	41444
+725	23595	41406
+726	23623	41365
+727	23648	41320
+728	23677	41281
+729	23700	41231
+730	23728	41192
+731	23752	41144
+732	23784	41111
+733	23807	41063
+734	23840	41031
+735	23870	40994
+736	23908	40972
+737	23941	40940
+738	23974	40909
+739	24006	40875
+740	24036	40838
+741	24064	40798
+742	24092	40759
+743	24127	40730
+744	24153	40688
+745	24179	40644
+746	24207	40604
+747	24233	40561
+748	24261	40522
+749	24295	40491
+750	24318	40444
+751	24349	40410
+752	24376	40368
+753	24408	40335
+754	24442	40306
+755	24474	40273
+756	24508	40242
+757	24548	40222
+758	24575	40182
+759	24605	40145
+760	24632	40104
+761	24660	40064
+762	24689	40027
+763	24714	39982
+764	24745	39949
+765	24766	39897
+766	24797	39863
+767	24825	39823
+768	24854	39786
+769	24880	39744
+770	24909	39706
+771	24940	39672
+772	24970	39635
+773	25004	39606
+774	25030	39564
+775	25056	39522
+776	25086	39486
+777	25107	39436
+778	25139	39403
+779	25159	39351
+780	25188	39314
+781	25214	39272
+782	25240	39230
+783	25266	39188
+784	25288	39141
+785	25315	39101
+786	25341	39058
+787	25367	39016
+788	25391	38972
+789	25417	38930
+790	25448	38895
+791	25482	38867
+792	25514	38834
+793	25542	38795
+794	25569	38756
+795	25595	38714
+796	25618	38669
+797	25643	38626
+798	25667	38581
+799	25695	38543
+800	25716	38494
+801	25743	38454
+802	25770	38415
+803	25790	38364
+804	25822	38332
+805	25843	38284
+806	25873	38249
+807	25896	38203
+808	25925	38167
+809	25955	38131
+810	25988	38101
+811	26028	38080
+812	26055	38042
+813	26081	38000
+814	26108	37961
+815	26131	37916
+816	26159	37878
+817	26188	37841
+818	26214	37800
+819	26242	37764
+820	26272	37728
+821	26298	37688
+822	26327	37652
+823	26359	37619
+824	26385	37580
+825	26408	37534
+826	26444	37507
+827	26477	37478
+828	26517	37456
+829	26539	37411
+830	26573	37382
+831	26597	37339
+832	26623	37298
+833	26650	37259
+834	26677	37221
+835	26704	37182
+836	26728	37138
+837	26763	37111
+838	26791	37073
+839	26822	37041
+840	26872	37033
+841	26924	37029
+842	26982	37033
+843	27054	37055
+844	27097	37038
+845	27120	36994
+846	27146	36954
+847	27180	36925
+848	27206	36884
+849	27234	36846
+850	27260	36807
+851	27289	36770
+852	27318	36734
+853	27347	36698
+854	27386	36675
+855	27413	36637
+856	27439	36596
+857	27471	36564
+858	27501	36529
+859	27535	36500
+860	27572	36474
+861	27595	36431
+862	27627	36398
+863	27654	36360
+864	27683	36324
+865	27711	36287
+866	27738	36249
+867	27765	36210
+868	27794	36175
+869	27820	36135
@@ -0,0 +1,115 @@
+import os
+import json
+import yaml
+from typing import Dict, Any, Optional
+
+
+class EnsembleConfig:
+    _instance: Optional['EnsembleConfig'] = None
+    _config: Dict[str, Any] = {}
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(EnsembleConfig, cls).__new__(cls)
+            cls._instance._load_config()
+        return cls._instance
+
+    def _load_config(self):
+        """Load configuration from YAML file."""
+        config_path = os.path.join(os.path.dirname(__file__), 'ensemble_config.yaml')
+        try:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                self._config = yaml.safe_load(f)
+            # print(f"✅ Loaded ensemble config from {config_path}")
+        except Exception as e:
+            print(f"❌ Failed to load ensemble config: {e}")
+            self._config = {}
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get configuration value by key (supports dot notation for nested keys)."""
+        keys = key.split('.')
+        value = self._config
+
+        try:
+            for k in keys:
+                value = value[k]
+            return value
+        except (KeyError, TypeError):
+            return default
+
+
+# Singleton accessor
+def get_config() -> EnsembleConfig:
+    return EnsembleConfig()
+
+
+# ── Market Thresholds Loader ────────────────────────────────────────────
+
+_market_thresholds_cache: Optional[Dict[str, Any]] = None
+
+
+def load_market_thresholds() -> Dict[str, Any]:
+    """
+    Load market thresholds from JSON config file.
+    Returns the full config dict with 'markets' and 'defaults' keys.
+    Caches after first load for performance.
+    """
+    global _market_thresholds_cache
+    if _market_thresholds_cache is not None:
+        return _market_thresholds_cache
+
+    config_path = os.path.join(os.path.dirname(__file__), 'market_thresholds.json')
+    try:
+        with open(config_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        _market_thresholds_cache = data
+        print(f"✅ Market thresholds loaded: {len(data.get('markets', {}))} markets (v={data.get('_meta', {}).get('version', '?')})")
+        return data
+    except Exception as e:
+        print(f"❌ Failed to load market thresholds: {e} — using built-in defaults")
+        _market_thresholds_cache = {"markets": {}, "defaults": {
+            "calibration": 0.55,
+            "min_conf": 55.0,
+            "min_play_score": 68.0,
+            "min_edge": 0.02,
+            "odds_band_min_sample": 0.0,
+            "odds_band_min_edge": 0.0,
+        }}
+        return _market_thresholds_cache
+
+
+def build_threshold_dict(field: str) -> Dict[str, float]:
+    """
+    Build a flat {market: value} dict for a specific threshold field.
+
+    Usage:
+        calibration_map = build_threshold_dict("calibration")
+        # → {"MS": 0.62, "DC": 0.82, ...}
+    """
+    data = load_market_thresholds()
+    markets = data.get("markets", {})
+    result: Dict[str, float] = {}
+    for market, cfg in markets.items():
+        if field in cfg:
+            result[market] = float(cfg[field])
+    return result
+
+
+def get_threshold_default(field: str) -> float:
+    """Get the default fallback value for a threshold field."""
+    data = load_market_thresholds()
+    defaults = data.get("defaults", {})
+    return float(defaults.get(field, 0.0))
+
+
+if __name__ == "__main__":
+    # Test
+    cfg = get_config()
+    print(f"Weights: {cfg.get('engine_weights')}")
+    print(f"Team Weight: {cfg.get('engine_weights.team')}")
+    print()
+    print("--- Market Thresholds ---")
+    for field in ["calibration", "min_conf", "min_play_score", "min_edge"]:
+        d = build_threshold_dict(field)
+        print(f"{field}: {d}")
+    print(f"Default calibration: {get_threshold_default('calibration')}")
@@ -0,0 +1,197 @@
+model_ensemble:
+  xgb_weight: 0.50
+  lgb_weight: 0.50
+  temperature: 1.5
+  default_ms_odds:
+    home: 2.65
+    draw: 3.20
+    away: 2.65
+  elo_staleness_days: 14
+  odds_staleness_hours: 48
+
+engine_weights:
+  team: 0.30
+  player: 0.25
+  odds: 0.30
+  referee: 0.15
+  min_weight: 0.05
+
+weight_redistribution:
+  player_missing_to_team: 0.5
+  player_missing_to_odds: 0.5
+  referee_missing_to_team: 0.4
+  referee_missing_to_odds: 0.6
+  referee_min_matches: 5
+
+match_result:
+  min_draw_prob: 0.15
+
+over_under:
+  prob_min: 0.02
+  prob_max: 0.98
+  ou15_threshold: 0.55
+  ou25_threshold: 0.52
+  ou35_threshold: 0.48
+  btts_threshold: 0.58
+  poisson_blend_weight: 0.25
+  poisson_grid_max: 6
+
+half_time:
+  ft_to_ht_ratio: 0.42
+  poisson_grid_max: 5
+  ht_over_05_min: 0.20
+  ht_over_05_max: 0.95
+  ht_ou_threshold: 0.55
+  ht_draw_floor: 0.28
+  low_xg_threshold: 2.0
+  low_xg_ratio_adjust: 0.85
+
+confidence:
+  agreement_boost: 1.3
+  disagreement_penalty: 0.7
+
+handicap:
+  xg_diff_threshold: 1.2
+
+corners:
+  xg_multiplier: 3.0
+  baseline: 3.0
+  home_dominant_bonus: 1.5
+  away_dominant_bonus: 1.0
+  dominance_threshold: 0.6
+  line: 9.5
+
+cards:
+  derby_heat_factor: 1.3
+  line: 4.5
+
+score:
+  poisson_grid_max: 7
+  ms_confidence_threshold: 15.0
+
+risk:
+  # Lowered thresholds for better surprise detection (was 0.20+)
+  # Model typically outputs 4-8% for reversals, so we need lower thresholds
+  surprise_threshold: 0.05
+  surprise_threshold_top: 0.05
+  surprise_threshold_non_top: 0.06
+  surprise_threshold_favorite_reversal: 0.06
+  surprise_threshold_favorite_reversal_top: 0.06
+  surprise_threshold_favorite_reversal_non_top: 0.08
+  surprise_threshold_underdog_reversal: 0.05
+  surprise_threshold_underdog_reversal_top: 0.05
+  surprise_threshold_underdog_reversal_non_top: 0.06
+  surprise_threshold_basketball: 0.08
+  surprise_threshold_basketball_top: 0.08
+  surprise_threshold_basketball_non_top: 0.10
+  surprise_min_top_gap: 0.01
+  surprise_min_top_gap_top: 0.01
+  surprise_min_top_gap_non_top: 0.015
+  # New: Upset alert threshold for potential upsets (lower than main threshold)
+  upset_alert_threshold: 0.05 # 5% - alert when reversal prob > 5%
+  htft_temperature: 1.25
+  htft_temperature_top: 1.25
+  htft_temperature_non_top: 1.35
+  htft_temperature_basketball: 1.08
+  htft_temperature_basketball_top: 1.08
+  htft_temperature_basketball_non_top: 1.15
+  htft_reversal_multiplier: 0.60
+  htft_reversal_multiplier_top: 0.60
+  htft_reversal_multiplier_non_top: 0.45
+  htft_reversal_multiplier_favorite: 0.72
+  htft_reversal_multiplier_favorite_top: 0.72
+  htft_reversal_multiplier_favorite_non_top: 0.55
+  htft_reversal_multiplier_underdog: 0.45
+  htft_reversal_multiplier_underdog_top: 0.45
+  htft_reversal_multiplier_underdog_non_top: 0.30
+  htft_reversal_multiplier_basketball: 0.90
+  htft_reversal_multiplier_basketball_top: 0.90
+  htft_reversal_multiplier_basketball_non_top: 0.75
+  htft_reversal_gap_medium: 0.50
+  htft_reversal_gap_strong: 1.00
+  htft_prior_min_matches: 300
+  htft_prior_blend_league: 0.65
+  htft_prior_blend_top: 0.50
+  htft_prior_blend_non_top: 0.58
+  htft_prior_odds_blend_top: 0.35
+  htft_prior_odds_blend_top_with_league: 0.22
+  htft_favorite_balance_gap: 0.20
+  htft_reversal_cap_factor: 2.30
+  extreme_upset: 0.7
+  high_upset: 0.5
+  medium_upset: 0.3
+  extreme_warnings: 3
+  high_warnings: 2
+  balanced_match_gap: 0.1
+  referee_min_data: 10
+
+recommendations:
+  confidence_threshold: 45
+  value_confidence_min: 10
+  value_confidence_max: 30
+  value_edge_margin: 0.02
+  value_upgrade_edge: 5.0
+
+  # ACİL DÜZELTİLDİ: Güvenilir marketler genişletildi
+  safe_markets: ['ÇŞ', '1.5 Üst/Alt', '2.5 Üst/Alt']
+
+  # ACİL DÜZELTİLDİ: Market bazlı minimum confidence threshold'lar (Artık Olasılık Yüzdesi!)
+  market_min_confidence:
+    MS: 50.0 # Match result is hardest; 50%+ true probability is actually strong
+    ÇŞ: 65.0 # Double chance naturally has high probability (2 sides of 3)
+    1.5 Üst/Alt: 70.0 # 1.5 Goals needs to be highly probable to be worth playing
+    2.5 Üst/Alt: 55.0 # Standard threshold for 50/50 lines
+    3.5 Üst/Alt: 60.0 # Needs higher certianty than 2.5
+    BTTS: 60.0 # Both Teams To Score - raised for accuracy (was 47.7%)
+
+  risk_safe_boost: 1.2
+  risk_ms_penalty_high: 0.5
+  risk_ms_penalty_medium: 0.8
+  risk_other_penalty: 0.7
+
+  # ACİL DÜZELTİLDİ: Market weights güvenilir marketlere göre ayarlandı
+  market_weights:
+    MS: 0.5 # ⬇️ Düşürüldü (zayıf performans)
+    ÇŞ: 1.5 # ⬆️ Artırıldı (güçlü performans)
+    1.5 Üst/Alt: 1.6 # ⬆️ En yüksek (en güvenilir)
+    2.5 Üst/Alt: 1.2 # ⬆️ Artırıldı
+    3.5 Üst/Alt: 0.9 # ⬇️ Düşürüldü
+    BTTS: 0.4 # ⬇️ Düşürüldü (zayıf performans)
+
+  # Confidence Calibration (backtest-derived accuracy)
+  baseline_accuracy: 65.0
+  market_accuracy:
+    MS: 52.1 # ❌ Zayıf
+    ÇŞ: 77.9 # ✅ İyi
+    1.5 Üst/Alt: 82.1 # ✅ Mükemmel
+    2.5 Üst/Alt: 61.4 # ⚠️ Orta
+    3.5 Üst/Alt: 60.7 # ⚠️ Orta
+    BTTS: 50.7 # ❌ Zayıf
+
+calibration_buckets:
+  ms_home:
+    heavy_fav: 1.40 # home odds <= 1.40
+    fav: 1.80 # home odds > 1.40 and <= 1.80
+    balanced: 2.50 # home odds > 1.80 and <= 2.50
+    underdog: 99.0 # home odds > 2.50
+
+team_xg:
+  home_base: 1.35
+  away_base: 1.10
+  home_conversion_mult: 3.0
+  away_conversion_mult: 2.5
+
+sidelined:
+  position_weights:
+    K: 0.35
+    D: 0.20
+    O: 0.25
+    F: 0.30
+  max_rating: 10
+  adaptation_threshold: 10
+  adaptation_discount: 0.5
+  goalkeeper_penalty: 0.15
+  confidence_boost: 10
+  max_impact: 0.85
+  key_player_threshold: 3
+  recent_matches_lookback: 15
@@ -0,0 +1,115 @@
+{
+  "_meta": {
+    "version": "v34",
+    "description": "Market-specific thresholds for the betting engine pipeline — V34 odds-aware gate fix",
+    "rule": "max_reachable (100 × calibration) MUST be > min_conf + 8",
+    "updated_at": "2026-05-10",
+    "changelog": "V34: Reduced min_edge to realistic levels for odds-aware V25 model. Model output ≈ market-implied, so large EV edges are mathematically impossible."
+  },
+  "markets": {
+    "MS": {
+      "calibration": 0.62,
+      "min_conf": 20.0,
+      "min_play_score": 28.0,
+      "min_edge": 0.005,
+      "odds_band_min_sample": 8.0,
+      "odds_band_min_edge": 0.005
+    },
+    "DC": {
+      "calibration": 0.82,
+      "min_conf": 40.0,
+      "min_play_score": 50.0,
+      "min_edge": 0.003,
+      "odds_band_min_sample": 8.0,
+      "odds_band_min_edge": 0.005
+    },
+    "OU15": {
+      "calibration": 0.84,
+      "min_conf": 45.0,
+      "min_play_score": 50.0,
+      "min_edge": 0.003,
+      "odds_band_min_sample": 8.0,
+      "odds_band_min_edge": 0.005
+    },
+    "OU25": {
+      "calibration": 0.68,
+      "min_conf": 30.0,
+      "min_play_score": 40.0,
+      "min_edge": 0.005,
+      "odds_band_min_sample": 8.0,
+      "odds_band_min_edge": 0.005
+    },
+    "OU35": {
+      "calibration": 0.60,
+      "min_conf": 20.0,
+      "min_play_score": 30.0,
+      "min_edge": 0.008,
+      "odds_band_min_sample": 8.0,
+      "odds_band_min_edge": 0.008
+    },
+    "BTTS": {
+      "calibration": 0.65,
+      "min_conf": 30.0,
+      "min_play_score": 40.0,
+      "min_edge": 0.005,
+      "odds_band_min_sample": 8.0,
+      "odds_band_min_edge": 0.005
+    },
+    "HT": {
+      "calibration": 0.58,
+      "min_conf": 20.0,
+      "min_play_score": 28.0,
+      "min_edge": 0.01,
+      "odds_band_min_sample": 8.0,
+      "odds_band_min_edge": 0.008
+    },
+    "HT_OU05": {
+      "calibration": 0.68,
+      "min_conf": 35.0,
+      "min_play_score": 42.0,
+      "min_edge": 0.005,
+      "odds_band_min_sample": 8.0,
+      "odds_band_min_edge": 0.005
+    },
+    "HT_OU15": {
+      "calibration": 0.60,
+      "min_conf": 25.0,
+      "min_play_score": 32.0,
+      "min_edge": 0.008,
+      "odds_band_min_sample": 8.0,
+      "odds_band_min_edge": 0.008
+    },
+    "OE": {
+      "calibration": 0.62,
+      "min_conf": 35.0,
+      "min_play_score": 32.0,
+      "min_edge": 0.005
+    },
+    "CARDS": {
+      "calibration": 0.58,
+      "min_conf": 30.0,
+      "min_play_score": 35.0,
+      "min_edge": 0.008
+    },
+    "HCAP": {
+      "calibration": 0.56,
+      "min_conf": 25.0,
+      "min_play_score": 30.0,
+      "min_edge": 0.015
+    },
+    "HTFT": {
+      "calibration": 0.45,
+      "min_conf": 10.0,
+      "min_play_score": 18.0,
+      "min_edge": 0.02
+    }
+  },
+  "defaults": {
+    "calibration": 0.55,
+    "min_conf": 55.0,
+    "min_play_score": 60.0,
+    "min_edge": 0.008,
+    "odds_band_min_sample": 0.0,
+    "odds_band_min_edge": 0.0
+  }
+}
@@ -0,0 +1,8 @@
+from .base_calculator import BaseCalculator, CalculationContext
+from .match_result_calculator import MatchResultCalculator
+from .over_under_calculator import OverUnderCalculator
+from .half_time_calculator import HalfTimeCalculator
+from .score_calculator import ScoreCalculator
+from .other_markets_calculator import OtherMarketsCalculator
+from .risk_assessor import RiskAssessor
+from .bet_recommender import BetRecommender, MarketPredictionDTO
@@ -0,0 +1,53 @@
+"""
+Base classes and context dataclass for all calculators.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class CalculationContext:
+    """Context object holding all inputs for calculators."""
+
+    team_pred: Any
+    player_pred: Any
+    odds_pred: Any
+    referee_pred: Any
+    upset_factors: Any
+
+    weights: dict[str, float]
+    player_mods: dict[str, float]
+    referee_mods: dict[str, float]
+
+    match_id: str
+    home_team_name: str
+    away_team_name: str
+
+    odds_data: dict[str, float]
+    home_xg: float
+    away_xg: float
+    total_xg: float
+
+    league_id: str | None = None
+    sport: str = "football"
+    is_top_league: bool = False
+
+    # Risk info (populated later)
+    risk_level: str = "MEDIUM"
+    is_surprise: bool = False
+
+    # XGBoost Predictions (New)
+    xgboost_preds: dict[str, Any] = field(default_factory=dict)
+
+
+class BaseCalculator:
+    """Base class for all market calculators."""
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        self.config = config
+
+    def calculate(self, ctx: CalculationContext) -> dict[str, Any]:
+        raise NotImplementedError("Subclasses must implement calculate()")
@@ -0,0 +1,210 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Any
+from .base_calculator import BaseCalculator, CalculationContext
+from .match_result_calculator import MatchResultPrediction
+from .over_under_calculator import OverUnderPrediction
+from .risk_assessor import RiskAnalysis
+
+
+@dataclass
+class MarketPredictionDTO:
+    market_type: str
+    pick: str
+    probability: float
+    confidence: float
+    odds: float = 0.0
+    is_recommended: bool = False
+    is_value_bet: bool = False
+    edge: float = 0.0
+    is_skip: bool = False  # NEW: If model is unsure, mark as skip
+
+@dataclass
+class RecommendationResult:
+    best_bet: Optional[MarketPredictionDTO]
+    recommended_bets: List[MarketPredictionDTO]
+    alternative_bet: Optional[MarketPredictionDTO]
+    value_bets: List[MarketPredictionDTO]
+    skipped_bets: List[MarketPredictionDTO]  # NEW: Track what we decided NOT to predict
+
+
+class BetRecommender(BaseCalculator):
+    def calculate(self,  # type: ignore[override]
+                  ctx: CalculationContext,
+                  ms_res: MatchResultPrediction,
+                  ou_res: OverUnderPrediction,
+                  risk: RiskAnalysis) -> RecommendationResult:
+
+        odds_data = ctx.odds_data
+
+        # Market-Specific Minimum Confidence Thresholds (Hard Gates)
+        # Below these, we say "I don't know" (SKIP)
+        min_conf_thresholds = {
+            "MS": 45.0,      # 3-way is hard, need at least 45%
+            "ÇŞ": 40.0,      # Double chance is safer, but still need 40%
+            "1.5 Üst/Alt": 50.0,
+            "2.5 Üst/Alt": 45.0,
+            "3.5 Üst/Alt": 45.0,
+            "BTTS": 45.0,
+            "HT": 40.0,
+        }
+
+        # Prepare candidates
+        markets = [
+            MarketPredictionDTO("MS", ms_res.ms_pick,
+                                ms_res.ms_home_prob if ms_res.ms_pick == "1" else (ms_res.ms_away_prob if ms_res.ms_pick == "2" else ms_res.ms_draw_prob),
+                                ms_res.ms_confidence,
+                                odds_data.get(f"ms_{ms_res.ms_pick.lower()}", 0)),
+
+            MarketPredictionDTO("ÇŞ", ms_res.dc_pick,
+                                ms_res.dc_1x_prob if ms_res.dc_pick == "1X" else (ms_res.dc_x2_prob if ms_res.dc_pick == "X2" else ms_res.dc_12_prob),
+                                ms_res.dc_confidence,
+                                odds_data.get(f"dc_{ms_res.dc_pick.lower()}", 0)),
+
+            MarketPredictionDTO("1.5 Üst/Alt", ou_res.ou15_pick,
+                                ou_res.over_15_prob if "Üst" in ou_res.ou15_pick else ou_res.under_15_prob,
+                                ou_res.ou15_confidence, 0),
+
+            MarketPredictionDTO("2.5 Üst/Alt", ou_res.ou25_pick,
+                                ou_res.over_25_prob if "Üst" in ou_res.ou25_pick else ou_res.under_25_prob,
+                                ou_res.ou25_confidence,
+                                odds_data.get("ou25_o" if "Üst" in ou_res.ou25_pick else "ou25_u", 0)),
+
+            MarketPredictionDTO("3.5 Üst/Alt", ou_res.ou35_pick,
+                                ou_res.over_35_prob if "Üst" in ou_res.ou35_pick else ou_res.under_35_prob,
+                                ou_res.ou35_confidence, 0),
+
+            MarketPredictionDTO("BTTS", ou_res.btts_pick,
+                                ou_res.btts_yes_prob if "Var" in ou_res.btts_pick else ou_res.btts_no_prob,
+                                ou_res.btts_confidence,
+                                odds_data.get("btts_y" if "Var" in ou_res.btts_pick else "btts_n", 0)),
+        ]
+
+        # Market weights from config (historical accuracy weighting)
+        market_weights = self.config.get("recommendations.market_weights", {})
+        default_weight = 1.0
+
+        safe_markets = set(self.config.get("recommendations.safe_markets", ["ÇŞ", "1.5 Üst/Alt"]))
+        risk_level = risk.risk_level
+
+        # Confidence calibration (backtest-derived accuracy scaling)
+        market_accuracy = self.config.get("recommendations.market_accuracy", {})
+        baseline_accuracy = self.config.get("recommendations.baseline_accuracy", 65.0)
+
+        def _calibrated_confidence(m):
+            """Scale raw confidence by market's historical accuracy ratio."""
+            accuracy = market_accuracy.get(m.market_type, baseline_accuracy) if isinstance(market_accuracy, dict) else baseline_accuracy
+            ratio = accuracy / baseline_accuracy
+            return m.confidence * ratio
+
+        def _score(m):
+            mw = market_weights.get(m.market_type, default_weight) if isinstance(market_weights, dict) else default_weight
+
+            # 1. Base Score: calibrated confidence * market weight
+            cal_conf = _calibrated_confidence(m)
+            score = cal_conf * mw
+
+            # 2. Value/Edge Bonus
+            odds_val = m.odds if m.odds is not None else 0.0
+            if odds_val > 0:
+                implied = 1.0 / odds_val
+                edge = (m.probability - implied) * 100
+                if edge > 0:
+                    score += edge * 4.0
+
+            # 3. Risk adjustment
+            if risk_level in ("HIGH", "EXTREME"):
+                if m.market_type in safe_markets:
+                    score *= self.config.get("recommendations.risk_safe_boost", 1.2)
+                elif m.market_type == "MS":
+                    score *= self.config.get("recommendations.risk_ms_penalty_high", 0.5)
+                else:
+                    score *= self.config.get("recommendations.risk_other_penalty", 0.7)
+            elif risk_level == "MEDIUM":
+                if m.market_type == "MS":
+                    score *= self.config.get("recommendations.risk_ms_penalty_medium", 0.8)
+
+            # 4. Extreme Confidence Bonus
+            if cal_conf > 80:
+                score *= 1.15
+
+            return score
+
+        recommended = []
+        value_bets = []
+        skipped_bets = []
+
+        conf_thr = self.config.get("recommendations.confidence_threshold", 60)
+
+        val_min = self.config.get("recommendations.value_confidence_min", 45) # Increased from 30
+        val_max = self.config.get("recommendations.value_confidence_max", 60)
+        val_margin = self.config.get("recommendations.value_edge_margin", 0.03) # Increased from 0.02
+        val_upgrade = self.config.get("recommendations.value_upgrade_edge", 5.0)
+
+        for m in markets:
+            # --- SKIP LOGIC (Hard Gate) ---
+            # 1. Confidence is below market threshold
+            min_conf = min_conf_thresholds.get(m.market_type, 45.0)
+            if m.confidence < min_conf:
+                m.is_skip = True
+                skipped_bets.append(m)
+                continue
+
+            # 2. Negative Value Edge (Odds are too low for our probability)
+            if m.odds > 0:
+                implied = 1.0 / m.odds
+                edge = m.probability - implied
+                # If our prob is significantly lower than implied (negative edge > 3%), SKIP
+                if edge < -0.03:
+                    m.is_skip = True
+                    skipped_bets.append(m)
+                    continue
+
+            # --- PROCESS BET ---
+            # 1. Regular recommended
+            if m.confidence >= conf_thr:
+                m.is_recommended = True
+                recommended.append(m)
+
+            # 2. Value bet logic
+            if m.confidence is not None and val_min <= m.confidence <= val_max and m.odds > 0:
+                implied = 1.0 / m.odds
+                if m.probability > (implied + val_margin):
+                    m.is_value_bet = True
+                    m.edge = (m.probability - implied) * 100
+
+                    if m.edge > val_upgrade:
+                        m.is_recommended = True
+                        recommended.append(m)
+                    else:
+                        value_bets.append(m)
+
+        # Best bet (from recommended only)
+        best_bet = None
+        if recommended:
+            # Re-sort only recommended markets to find the best one
+            valid_markets = [m for m in markets if not m.is_skip and m.is_recommended]
+            if valid_markets:
+                valid_markets.sort(key=_score, reverse=True)
+                best_bet = valid_markets[0]
+                best_bet.is_recommended = True
+
+        # Alternative bet
+        alternative = None
+        if risk.is_surprise_risk and ms_res.ms_pick in ["1", "2"]:
+            # Check if alternative is not skipped
+            alt_candidate = MarketPredictionDTO(
+                "2.5 Üst/Alt", ou_res.ou25_pick,
+                ou_res.over_25_prob if "Üst" in ou_res.ou25_pick else ou_res.under_25_prob,
+                ou_res.ou25_confidence,
+                odds_data.get("ou25_o" if "Üst" in ou_res.ou25_pick else "ou25_u", 0)
+            )
+            if alt_candidate.confidence >= min_conf_thresholds.get("2.5 Üst/Alt", 45.0):
+                alternative = alt_candidate
+
+        return RecommendationResult(
+            best_bet=best_bet,
+            recommended_bets=recommended,
+            alternative_bet=alternative,
+            value_bets=value_bets,
+            skipped_bets=skipped_bets
+        )
@@ -0,0 +1,32 @@
+def calc_confidence_3way(top_prob: float) -> float:
+    """Returns the true win probability percentage (e.g. 0.45 -> 45.0)."""
+    return max(0, min(99.0, top_prob * 100))
+
+def calc_confidence_2way(prob: float) -> float:
+    """Returns the true win probability percentage for the favored side."""
+    # Find the probability of the >0.5 side
+    win_prob = prob if prob >= 0.5 else (1.0 - prob)
+    return max(0, min(99.0, win_prob * 100))
+
+def calc_confidence_dc(top_prob: float) -> float:
+    """Returns the true win probability percentage for double chance."""
+    return max(0, min(99.0, top_prob * 100))
+
+def calc_confidence_3way_with_agreement(top_prob: float, agreement_ratio: float,
+                                         boost: float = 1.05, penalty: float = 0.95) -> float:
+    """
+    Returns the true win probability percentage, slightly adjusted by engine consensus.
+    
+    Args:
+        top_prob: highest probability among options
+        agreement_ratio: 0.0 to 1.0 — how many engines agree on the pick
+    """
+    base = calc_confidence_3way(top_prob)
+    
+    # Slight nudge rather than massive swing, to keep it feeling like a true probability
+    if agreement_ratio >= 0.75:
+        return min(99.0, base * boost)
+    elif agreement_ratio <= 0.25:
+        return max(0.0, base * penalty)
+    
+    return base
@@ -0,0 +1,131 @@
+"""
+Expert Recommendation Engine (Senior Level)
+============================================
+Evaluates ALL markets, classifies by risk, and ensures NO "empty" recommendations.
+Prioritizes user safety by clearly labeling risk levels.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Any, Dict
+from .base_calculator import BaseCalculator, CalculationContext
+from .match_result_calculator import MatchResultPrediction
+from .over_under_calculator import OverUnderPrediction
+from .risk_assessor import RiskAnalysis
+
+
+@dataclass
+class ExpertPick:
+    market_type: str
+    pick: str
+    probability: float
+    confidence: float
+    odds: float
+    edge: float  # Expected value percentage
+    
+    # Risk Classification
+    risk_level: str  # SAFE, MEDIUM, RISKY, SURPRISE
+    reasoning: str   # Why this pick? (e.g., "High xG support", "Value detected")
+
+@dataclass
+class ExpertResult:
+    main_pick: ExpertPick
+    safe_alternative: Optional[ExpertPick]
+    value_picks: List[ExpertPick]
+    surprise_picks: List[ExpertPick]
+    market_summary: Dict[str, float] # {market: probability}
+
+
+class ExpertRecommender(BaseCalculator):
+    def calculate(self,  # type: ignore[override]
+                  ctx: CalculationContext,
+                  ms_res: MatchResultPrediction,
+                  ou_res: OverUnderPrediction,
+                  risk: RiskAnalysis) -> ExpertResult:
+
+        odds_data = ctx.odds_data
+        all_picks: List[ExpertPick] = []
+
+        # ─── 1. Helper to Evaluate Pick ───
+        def evaluate(market: str, pick: str, prob: float, odd_key: str):
+            odd_val = float(odds_data.get(odd_key, 0))
+            # If odd is missing/low, estimate it via probability (Kelly-ish estimation)
+            if odd_val <= 1.01:
+                odd_val = round(1.0 / (prob + 0.05), 2) # Conservative estimation
+                reasoning = "Derived (No market odd)"
+            else:
+                reasoning = "Market Confirmed"
+
+            implied = 1.0 / odd_val
+            edge = (prob - implied) * 100
+
+            # ─── Risk Classification ───
+            if prob >= 0.75 and odd_val <= 1.45:
+                level = "SAFE"
+            elif edge > 5.0:
+                level = "VALUE"
+            elif odd_val >= 2.50 and prob >= 0.35:
+                level = "SURPRISE"
+            else:
+                level = "MEDIUM"
+
+            all_picks.append(ExpertPick(
+                market_type=market, pick=pick, probability=prob,
+                confidence=prob * 100, odds=odd_val, edge=edge,
+                risk_level=level, reasoning=reasoning
+            ))
+
+        # ─── 2. Evaluate All Major Markets ───
+        # MS
+        evaluate("MS", ms_res.ms_pick, 
+                 ms_res.ms_home_prob if ms_res.ms_pick == "1" else (ms_res.ms_away_prob if ms_res.ms_pick == "2" else ms_res.ms_draw_prob),
+                 f"ms_{ms_res.ms_pick.lower()}")
+        
+        # Double Chance
+        evaluate("DC", ms_res.dc_pick,
+                 ms_res.dc_1x_prob if ms_res.dc_pick == "1X" else (ms_res.dc_x2_prob if ms_res.dc_pick == "X2" else ms_res.dc_12_prob),
+                 f"dc_{ms_res.dc_pick.lower()}")
+
+        # OU25
+        evaluate("OU25", ou_res.ou25_pick,
+                 ou_res.over_25_prob if "Üst" in ou_res.ou25_pick else ou_res.under_25_prob,
+                 "ou25_o" if "Üst" in ou_res.ou25_pick else "ou25_u")
+
+        # BTTS
+        evaluate("BTTS", ou_res.btts_pick,
+                 ou_res.btts_yes_prob if "Var" in ou_res.btts_pick else ou_res.btts_no_prob,
+                 "btts_y" if "Var" in ou_res.btts_pick else "btts_n")
+
+        # OU15
+        evaluate("OU15", ou_res.ou15_pick,
+                 ou_res.over_15_prob if "Üst" in ou_res.ou15_pick else ou_res.under_15_prob,
+                 "ou15_o" if "Üst" in ou_res.ou15_pick else "ou15_u")
+
+        # ─── 3. Sort and Select ───
+        # Sort by a mix of Confidence and Edge
+        all_picks.sort(key=lambda p: (p.probability * 0.6) + (max(0, p.edge/100) * 0.4), reverse=True)
+
+        main = all_picks[0]
+        
+        # Find Safe Alternative (if main isn't Safe)
+        safe_alt = next((p for p in all_picks if p.risk_level == "SAFE"), None)
+        if safe_alt == main: safe_alt = None
+
+        value_picks = [p for p in all_picks if p.risk_level == "VALUE" and p != main]
+        surprise_picks = [p for p in all_picks if p.risk_level == "SURPRISE"]
+
+        # Market Summary for UI
+        market_summary = {
+            "MS_Home": ms_res.ms_home_prob,
+            "MS_Draw": ms_res.ms_draw_prob,
+            "MS_Away": ms_res.ms_away_prob,
+            "OU25_Over": ou_res.over_25_prob,
+            "BTTS_Yes": ou_res.btts_yes_prob
+        }
+
+        return ExpertResult(
+            main_pick=main,
+            safe_alternative=safe_alt,
+            value_picks=value_picks,
+            surprise_picks=surprise_picks,
+            market_summary=market_summary
+        )
@@ -0,0 +1,179 @@
+import math
+from dataclasses import dataclass
+from .base_calculator import BaseCalculator, CalculationContext
+from .confidence import calc_confidence_3way, calc_confidence_2way
+
+
+@dataclass
+class HalfTimePrediction:
+    ht_home_prob: float
+    ht_draw_prob: float
+    ht_away_prob: float
+    ht_pick: str
+    ht_confidence: float
+    
+    ht_over_05_prob: float
+    ht_under_05_prob: float
+    ht_over_15_prob: float
+    ht_under_15_prob: float
+    ht_ou_pick: str
+    ht_ou15_pick: str
+    
+    ht_home_xg: float
+    ht_away_xg: float
+
+
+class HalfTimeCalculator(BaseCalculator):
+    
+    def _poisson_pmf(self, k, lam):
+        """Poisson probability mass function."""
+        if lam <= 0:
+            return 1.0 if k == 0 else 0.0
+        return (lam ** k) * math.exp(-lam) / math.factorial(k)
+        
+    def calculate(self, ctx: CalculationContext) -> HalfTimePrediction:  # type: ignore[override]
+        team_pred = ctx.team_pred
+        odds_pred = ctx.odds_pred
+        
+        # Config
+        ft_to_ht_ratio = self.config.get("half_time.ft_to_ht_ratio", 0.42)
+        grid_max = self.config.get("half_time.poisson_grid_max", 5)
+        draw_floor = self.config.get("half_time.ht_draw_floor", 0.35)
+        low_xg_thr = self.config.get("half_time.low_xg_threshold", 2.0)
+        low_xg_adj = self.config.get("half_time.low_xg_ratio_adjust", 0.85)
+        
+        # FT xG (blended team + odds)
+        ft_home_xg = (team_pred.home_xg + odds_pred.poisson_home_xg) / 2
+        ft_away_xg = (team_pred.away_xg + odds_pred.poisson_away_xg) / 2
+        total_ft_xg = ft_home_xg + ft_away_xg
+        
+        # Dynamic HT ratio: düşük xG maçlarda ratio'yu küçült
+        # Çünkü düşük gollü maçlarda ilk yarıda gol olma ihtimali daha da düşük
+        effective_ratio = ft_to_ht_ratio
+        if total_ft_xg < low_xg_thr:
+            effective_ratio *= low_xg_adj
+        
+        # HT xG
+        ht_home_xg = ft_home_xg * effective_ratio
+        ht_away_xg = ft_away_xg * effective_ratio
+        ht_total_xg = ht_home_xg + ht_away_xg
+        
+        # Compute HT 1X2 via bivariate Poisson grid
+        ht_home = 0.0
+        ht_away = 0.0
+        ht_draw = 0.0
+        
+        # Also compute O/U while iterating
+        total_goals_prob = {}
+        
+        for i in range(grid_max):
+            for j in range(grid_max):
+                p = self._poisson_pmf(i, ht_home_xg) * self._poisson_pmf(j, ht_away_xg)
+                if i > j:
+                    ht_home += p
+                elif i < j:
+                    ht_away += p
+                else:
+                    ht_draw += p
+                
+                total = i + j
+                total_goals_prob[total] = total_goals_prob.get(total, 0.0) + p
+        
+        # Draw floor: düşük xG maçlarda beraberlik olasılığını minimum seviyeye çek
+        if ht_draw < draw_floor:
+            deficit = draw_floor - ht_draw
+            ht_draw = draw_floor
+            # Deficit'i home ve away'den orantılı düş
+            total_ha = ht_home + ht_away
+            if total_ha > 0:
+                ht_home -= deficit * (ht_home / total_ha)
+                ht_away -= deficit * (ht_away / total_ha)
+        
+        # Normalize
+        total_prob = ht_home + ht_draw + ht_away
+        if total_prob > 0:
+            ht_home /= total_prob
+            ht_draw /= total_prob
+            ht_away /= total_prob
+            
+        # XGBoost Integration (HT 1X2 and HT/FT Models)
+        w_xgb = self.config.get("xgboost.weight_ht", 0.60)
+        xgb_ht_home, xgb_ht_draw, xgb_ht_away = None, None, None
+        
+        if "ht_result" in ctx.xgboost_preds:
+            probs = ctx.xgboost_preds["ht_result"]
+            xgb_ht_home, xgb_ht_draw, xgb_ht_away = probs["home"], probs["draw"], probs["away"]
+        elif "ht_ft" in ctx.xgboost_preds:
+            # Fallback to HT/FT marginals
+            htft_payload = ctx.xgboost_preds.get("ht_ft", {})
+            probs = None
+            if isinstance(htft_payload, dict):
+                labels = ("1/1", "1/X", "1/2", "X/1", "X/X", "X/2", "2/1", "2/X", "2/2")
+                if all(label in htft_payload for label in labels):
+                    probs = [float(htft_payload[label]) for label in labels]
+
+            if probs is None:
+                probs = ctx.xgboost_preds.get("ht_ft_raw")
+            if probs is not None and len(probs) == 9:
+                xgb_ht_home = sum(probs[0:3])
+                xgb_ht_draw = sum(probs[3:6])
+                xgb_ht_away = sum(probs[6:9])
+
+        if xgb_ht_home is not None:
+            ht_home = ht_home * (1 - w_xgb) + xgb_ht_home * w_xgb
+            ht_draw = ht_draw * (1 - w_xgb) + xgb_ht_draw * w_xgb
+            ht_away = ht_away * (1 - w_xgb) + xgb_ht_away * w_xgb
+            
+            # Re-normalize
+            total = ht_home + ht_draw + ht_away
+            ht_home /= total
+            ht_draw /= total
+            ht_away /= total
+                    
+        # HT O/U 0.5
+        ht_over_05 = 1.0 - math.exp(-ht_total_xg)
+        if "ht_ou05" in ctx.xgboost_preds:
+            w_xgb = self.config.get("xgboost.weight_ou", 0.60)
+            xgb_ht_over_05 = float(ctx.xgboost_preds["ht_ou05"])
+            ht_over_05 = ht_over_05 * (1 - w_xgb) + xgb_ht_over_05 * w_xgb
+
+        ht_over_05_min = self.config.get("half_time.ht_over_05_min", 0.20)
+        ht_over_05_max = self.config.get("half_time.ht_over_05_max", 0.95)
+        ht_over_05 = max(ht_over_05_min, min(ht_over_05_max, ht_over_05))
+        
+        # HT O/U 1.5
+        # P(total >= 2) = 1 - P(0) - P(1)
+        ht_over_15 = sum(p for g, p in total_goals_prob.items() if g >= 2)
+        if "ht_ou15" in ctx.xgboost_preds:
+            w_xgb = self.config.get("xgboost.weight_ou", 0.60)
+            xgb_ht_over_15 = float(ctx.xgboost_preds["ht_ou15"])
+            ht_over_15 = ht_over_15 * (1 - w_xgb) + xgb_ht_over_15 * w_xgb
+            
+        ht_over_15 = max(0.02, min(0.95, ht_over_15))
+        
+        # Picks
+        ht_probs = [(ht_home, "İY 1"), (ht_draw, "İY X"), (ht_away, "İY 2")]
+        ht_sorted = sorted(ht_probs, key=lambda x: x[0], reverse=True)
+        ht_pick = ht_sorted[0][1]
+        ht_confidence = calc_confidence_3way(ht_sorted[0][0])
+        
+        # HT O/U picks
+        ht_ou_thr = self.config.get("half_time.ht_ou_threshold", 0.55)
+        ht_ou_pick = "İY 0.5 Üst" if ht_over_05 > ht_ou_thr else "İY 0.5 Alt"
+        ht_ou15_pick = "İY 1.5 Üst" if ht_over_15 > 0.45 else "İY 1.5 Alt"
+        
+        return HalfTimePrediction(
+            ht_home_prob=ht_home,
+            ht_draw_prob=ht_draw,
+            ht_away_prob=ht_away,
+            ht_pick=ht_pick,
+            ht_confidence=ht_confidence,
+            ht_over_05_prob=ht_over_05,
+            ht_under_05_prob=1.0 - ht_over_05,
+            ht_over_15_prob=ht_over_15,
+            ht_under_15_prob=1.0 - ht_over_15,
+            ht_ou_pick=ht_ou_pick,
+            ht_ou15_pick=ht_ou15_pick,
+            ht_home_xg=ht_home_xg,
+            ht_away_xg=ht_away_xg
+        )
@@ -0,0 +1,142 @@
+from dataclasses import dataclass
+from typing import Dict, Any, List
+from .base_calculator import BaseCalculator, CalculationContext
+from .confidence import calc_confidence_3way_with_agreement, calc_confidence_dc
+
+@dataclass
+class MatchResultPrediction:
+    ms_home_prob: float
+    ms_draw_prob: float
+    ms_away_prob: float
+    ms_pick: str
+    ms_confidence: float
+    
+    dc_1x_prob: float
+    dc_x2_prob: float
+    dc_12_prob: float
+    dc_pick: str
+    dc_confidence: float
+
+class MatchResultCalculator(BaseCalculator):
+    
+    def _get_engine_winner(self, home_prob: float, draw_prob: float, away_prob: float) -> str:
+        """Determine which outcome an engine favors."""
+        probs = {"1": home_prob, "X": draw_prob, "2": away_prob}
+        return max(probs, key=probs.__getitem__)
+    
+    def calculate(self, ctx: CalculationContext) -> MatchResultPrediction:  # type: ignore[override]
+        # Weights
+        w_team = ctx.weights["team"]
+        w_player = ctx.weights["player"]
+        w_odds = ctx.weights["odds"]
+        w_referee = ctx.weights["referee"]
+        
+        # Engine predictions
+        team_pred = ctx.team_pred
+        odds_pred = ctx.odds_pred
+        player_mods = ctx.player_mods
+        referee_mods = ctx.referee_mods
+        
+        # Weighted ensemble for 1X2
+        ms_home = (
+            team_pred.home_win_prob * w_team +
+            odds_pred.market_home_prob * w_odds +
+            team_pred.home_win_prob * player_mods["home_modifier"] * w_player +
+            odds_pred.market_home_prob * referee_mods["home_modifier"] * w_referee
+        )
+        
+        ms_away = (
+            team_pred.away_win_prob * w_team +
+            odds_pred.market_away_prob * w_odds +
+            team_pred.away_win_prob * player_mods["away_modifier"] * w_player +
+            odds_pred.market_away_prob / referee_mods["home_modifier"] * w_referee
+        )
+        
+        ms_draw = 1.0 - ms_home - ms_away
+        
+        # XGBoost Integration
+        if "ms" in ctx.xgboost_preds:
+            xgb_probs = ctx.xgboost_preds["ms"]
+            w_xgb = self.config.get("xgboost.weight_ms", 0.70)
+            w_heuristic = 1.0 - w_xgb
+            
+            ms_home = ms_home * w_heuristic + xgb_probs["home"] * w_xgb
+            ms_draw = ms_draw * w_heuristic + xgb_probs["draw"] * w_xgb
+            ms_away = ms_away * w_heuristic + xgb_probs["away"] * w_xgb
+            
+            # Re-normalize
+            total = ms_home + ms_draw + ms_away
+            ms_home /= total
+            ms_draw /= total
+            ms_away /= total
+        
+        # Min draw probability clamping
+        min_draw = self.config.get("match_result.min_draw_prob", 0.15)
+        if ms_draw < min_draw:
+            ms_draw = min_draw
+            total = ms_home + ms_away + ms_draw
+            ms_home /= total
+            ms_away /= total
+            ms_draw /= total
+            
+        # Double Chance
+        dc_1x = ms_home + ms_draw
+        dc_x2 = ms_draw + ms_away
+        dc_12 = ms_home + ms_away
+        
+        # MS pick
+        ms_probs = [(ms_home, "1"), (ms_draw, "X"), (ms_away, "2")]
+        ms_sorted = sorted(ms_probs, key=lambda x: x[0], reverse=True)
+        ms_pick = ms_sorted[0][1]
+        
+        # === ENGINE AGREEMENT ===
+        # Determine each engine's winner and calculate agreement ratio
+        team_winner = self._get_engine_winner(
+            team_pred.home_win_prob, team_pred.draw_prob, team_pred.away_win_prob
+        )
+        odds_winner = self._get_engine_winner(
+            odds_pred.market_home_prob, odds_pred.market_draw_prob, odds_pred.market_away_prob
+        )
+        
+        # Player-modified: team probs * player modifiers
+        player_adj_home = team_pred.home_win_prob * player_mods["home_modifier"]
+        player_adj_away = team_pred.away_win_prob * player_mods["away_modifier"]
+        player_adj_draw = max(0.01, 1.0 - player_adj_home - player_adj_away)
+        player_winner = self._get_engine_winner(player_adj_home, player_adj_draw, player_adj_away)
+        
+        # Referee-modified: odds probs * referee modifiers
+        ref_adj_home = odds_pred.market_home_prob * referee_mods["home_modifier"]
+        ref_adj_away = odds_pred.market_away_prob / referee_mods["home_modifier"]
+        ref_adj_draw = max(0.01, 1.0 - ref_adj_home - ref_adj_away)
+        referee_winner = self._get_engine_winner(ref_adj_home, ref_adj_draw, ref_adj_away)
+        
+        # Count how many engines agree with final pick
+        engines = [team_winner, odds_winner, player_winner, referee_winner]
+        agreement_count = sum(1 for e in engines if e == ms_pick)
+        agreement_ratio = agreement_count / len(engines)
+        
+        # Confidence with agreement
+        boost = self.config.get("confidence.agreement_boost", 1.3)
+        penalty = self.config.get("confidence.disagreement_penalty", 0.7)
+        ms_confidence = calc_confidence_3way_with_agreement(
+            ms_sorted[0][0], agreement_ratio, boost, penalty
+        )
+        
+        # DC pick
+        dc_probs = [(dc_1x, "1X"), (dc_x2, "X2"), (dc_12, "12")]
+        dc_sorted = sorted(dc_probs, key=lambda x: x[0], reverse=True)
+        dc_pick = dc_sorted[0][1]
+        dc_confidence = calc_confidence_dc(dc_sorted[0][0])
+        
+        return MatchResultPrediction(
+            ms_home_prob=ms_home,
+            ms_draw_prob=ms_draw,
+            ms_away_prob=ms_away,
+            ms_pick=ms_pick,
+            ms_confidence=ms_confidence,
+            dc_1x_prob=dc_1x,
+            dc_x2_prob=dc_x2,
+            dc_12_prob=dc_12,
+            dc_pick=dc_pick,
+            dc_confidence=dc_confidence
+        )
@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from typing import Dict, Tuple
+
+@dataclass
+class AnomalyResult:
+    is_anomaly: bool
+    side: str = ""
+    severity: float = 0.0
+    reason: str = ""
+
+class OddsAnomalyDetector:
+    """
+    Detects mismatches between bookmaker odds and underlying team metrics.
+    A 'Bookmaker Trap' is when a team has very low odds (heavy favorite)
+    but their xG/defense metrics are surprisingly poor.
+    """
+    
+    def __init__(self, config: Dict):
+        self.config = config
+        
+        # Thresholds
+        self.fav_odds_threshold = self.config.get("anomaly.fav_odds_threshold", 1.75)
+        self.min_xg_for_fav = self.config.get("anomaly.min_xg_for_fav", 1.25)
+        self.max_conceded_for_fav = self.config.get("anomaly.max_conceded_for_fav", 1.30)
+        self.opp_min_xg_threat = self.config.get("anomaly.opp_min_xg_threat", 1.10)
+        
+    def detect_trap(self, 
+                    odds_data: Dict[str, float], 
+                    home_xg: float, 
+                    away_xg: float, 
+                    home_conceded_avg: float, 
+                    away_conceded_avg: float) -> tuple[bool, AnomalyResult]:
+        """
+        Check if the match is a potential odds trap.
+        Returns: (has_trap, AnomalyResult)
+        """
+        ms_h = odds_data.get("ms_h", 0.0)
+        ms_a = odds_data.get("ms_a", 0.0)
+        
+        # Check Home Favorite Trap
+        if 1.0 < ms_h <= self.fav_odds_threshold:
+            # Home is favored. Check metrics.
+            if home_xg < self.min_xg_for_fav and (away_xg > self.opp_min_xg_threat or home_conceded_avg > self.max_conceded_for_fav):
+                severity = (self.fav_odds_threshold - ms_h) + (self.min_xg_for_fav - home_xg)
+                reason = f"🚨 ODDS ANOMALY (TRAP): Home odds ({ms_h}) suspiciously low despite poor metrics (xG: {round(home_xg, 2)}, Conceded: {round(home_conceded_avg, 2)})"
+                return True, AnomalyResult(True, "H", min(10.0, severity * 2), reason)
+
+        # Check Away Favorite Trap
+        if 1.0 < ms_a <= self.fav_odds_threshold:
+            # Away is favored. Check metrics
+            if away_xg < self.min_xg_for_fav and (home_xg > self.opp_min_xg_threat or away_conceded_avg > self.max_conceded_for_fav):
+                severity = (self.fav_odds_threshold - ms_a) + (self.min_xg_for_fav - away_xg)
+                reason = f"🚨 ODDS ANOMALY (TRAP): Away odds ({ms_a}) suspiciously low despite poor metrics (xG: {round(away_xg, 2)}, Conceded: {round(away_conceded_avg, 2)})"
+                return True, AnomalyResult(True, "A", min(10.0, severity * 2), reason)
+                
+        return False, AnomalyResult(False)
@@ -0,0 +1,115 @@
+from dataclasses import dataclass
+import math
+
+from .base_calculator import BaseCalculator, CalculationContext
+from .match_result_calculator import MatchResultPrediction
+
+
+@dataclass
+class OtherMarketsPrediction:
+    total_corners_pred: float
+    corner_pick: str | None
+
+    total_cards_pred: float
+    card_pick: str
+    cards_over_prob: float
+    cards_under_prob: float
+    cards_confidence: float
+
+    handicap_pick: str
+    handicap_home_prob: float
+    handicap_draw_prob: float
+    handicap_away_prob: float
+    handicap_confidence: float
+
+    odd_even_pick: str
+    odd_prob: float
+    even_prob: float
+
+
+class OtherMarketsCalculator(BaseCalculator):
+    def calculate(  # type: ignore[override]
+        self,
+        ctx: CalculationContext,
+        ms_result: MatchResultPrediction,
+    ) -> OtherMarketsPrediction:
+        if "handicap_ms" in ctx.xgboost_preds:
+            handicap_payload = ctx.xgboost_preds["handicap_ms"]
+            handicap_home_prob = float(handicap_payload.get("h1", 0.33))
+            handicap_draw_prob = float(handicap_payload.get("hx", 0.34))
+            handicap_away_prob = float(handicap_payload.get("h2", 0.33))
+        else:
+            xg_diff = ctx.home_xg - ctx.away_xg
+            threshold = float(self.config.get("handicap.xg_diff_threshold", 1.2))
+            if xg_diff > threshold:
+                handicap_home_prob, handicap_draw_prob, handicap_away_prob = 0.58, 0.24, 0.18
+            elif xg_diff < -threshold:
+                handicap_home_prob, handicap_draw_prob, handicap_away_prob = 0.18, 0.24, 0.58
+            else:
+                handicap_home_prob, handicap_draw_prob, handicap_away_prob = 0.28, 0.44, 0.28
+
+        handicap_confidence = max(
+            handicap_home_prob,
+            handicap_draw_prob,
+            handicap_away_prob,
+        ) * 100.0
+        if handicap_home_prob >= handicap_draw_prob and handicap_home_prob >= handicap_away_prob:
+            handicap_pick = "H 1 (Ev -1)"
+        elif handicap_away_prob >= handicap_home_prob and handicap_away_prob >= handicap_draw_prob:
+            handicap_pick = "H 2 (Dep -1)"
+        else:
+            handicap_pick = "H 0 (Beraberlik)"
+
+        total_corners = 0.0
+        corner_pick = None
+
+        card_line = float(self.config.get("cards.line", 4.5))
+        if "cards_ou45" in ctx.xgboost_preds:
+            cards_over_prob = float(ctx.xgboost_preds["cards_ou45"])
+            total_cards = 5.0 if cards_over_prob > 0.50 else 3.5
+        else:
+            referee_average = float(ctx.referee_pred.avg_yellow_cards)
+            match_heat = 1.0
+            is_derby = bool(
+                ctx.upset_factors.reasoning
+                and "DERBY" in str(ctx.upset_factors.reasoning[0]),
+            )
+            if is_derby:
+                match_heat = float(self.config.get("cards.derby_heat_factor", 1.3))
+            total_cards = referee_average * match_heat
+            delta = total_cards - card_line
+            cards_over_prob = 1.0 / (1.0 + math.exp(-delta * 0.9))
+
+        cards_over_prob = max(0.02, min(0.98, cards_over_prob))
+        cards_under_prob = 1.0 - cards_over_prob
+        cards_confidence = max(cards_over_prob, cards_under_prob) * 100.0
+        card_pick = f"{card_line} Ust" if cards_over_prob > 0.50 else f"{card_line} Alt"
+
+        lambda_total = ctx.total_xg
+        even_prob = math.exp(-lambda_total) * math.cosh(lambda_total)
+        if "odd_even" in ctx.xgboost_preds:
+            xgb_weight = float(self.config.get("xgboost.weight_ou", 0.60))
+            xgb_even_prob = float(ctx.xgboost_preds["odd_even"])
+            even_prob = even_prob * (1 - xgb_weight) + xgb_even_prob * xgb_weight
+
+        even_prob = max(0.02, min(0.98, even_prob))
+        odd_prob = 1.0 - even_prob
+        odd_even_pick = "Cift" if even_prob > 0.5 else "Tek"
+
+        return OtherMarketsPrediction(
+            total_corners_pred=total_corners,
+            corner_pick=corner_pick,
+            total_cards_pred=total_cards,
+            card_pick=card_pick,
+            cards_over_prob=cards_over_prob,
+            cards_under_prob=cards_under_prob,
+            cards_confidence=cards_confidence,
+            handicap_pick=handicap_pick,
+            handicap_home_prob=handicap_home_prob,
+            handicap_draw_prob=handicap_draw_prob,
+            handicap_away_prob=handicap_away_prob,
+            handicap_confidence=handicap_confidence,
+            odd_even_pick=odd_even_pick,
+            odd_prob=odd_prob,
+            even_prob=even_prob,
+        )
@@ -0,0 +1,174 @@
+import math
+from dataclasses import dataclass
+from .base_calculator import BaseCalculator, CalculationContext
+from .confidence import calc_confidence_2way
+
+@dataclass
+class OverUnderPrediction:
+    over_15_prob: float
+    under_15_prob: float
+    ou15_pick: str
+    ou15_confidence: float
+    
+    over_25_prob: float
+    under_25_prob: float
+    ou25_pick: str
+    ou25_confidence: float
+    
+    over_35_prob: float
+    under_35_prob: float
+    ou35_pick: str
+    ou35_confidence: float
+    
+    btts_yes_prob: float
+    btts_no_prob: float
+    btts_pick: str
+    btts_confidence: float
+
+
+class OverUnderCalculator(BaseCalculator):
+    
+    def _poisson_pmf(self, k: int, lam: float) -> float:
+        if lam <= 0:
+            return 1.0 if k == 0 else 0.0
+        return (lam ** k) * math.exp(-lam) / math.factorial(k)
+    
+    def _poisson_ou_probs(self, home_xg: float, away_xg: float, grid_max: int = 6):
+        """Bivariate Poisson grid → O/U probabilities."""
+        total_goals_prob = {}  # total_goals → cumulative probability
+        
+        for i in range(grid_max):
+            for j in range(grid_max):
+                p = self._poisson_pmf(i, home_xg) * self._poisson_pmf(j, away_xg)
+                total = i + j
+                total_goals_prob[total] = total_goals_prob.get(total, 0.0) + p
+        
+        # Cumulative
+        over_15 = sum(p for g, p in total_goals_prob.items() if g >= 2)
+        over_25 = sum(p for g, p in total_goals_prob.items() if g >= 3)
+        over_35 = sum(p for g, p in total_goals_prob.items() if g >= 4)
+        
+        # BTTS: P(home >= 1) * P(away >= 1)
+        p_home_0 = self._poisson_pmf(0, home_xg)
+        p_away_0 = self._poisson_pmf(0, away_xg)
+        btts_yes = (1 - p_home_0) * (1 - p_away_0)
+        
+        return over_15, over_25, over_35, btts_yes
+    
+    def calculate(self, ctx: CalculationContext) -> OverUnderPrediction:  # type: ignore[override]
+        odds_pred = ctx.odds_pred
+        referee_mods = ctx.referee_mods
+        
+        # Config
+        prob_min = self.config.get("over_under.prob_min", 0.02)
+        prob_max = self.config.get("over_under.prob_max", 0.98)
+        blend_w = self.config.get("over_under.poisson_blend_weight", 0.4)
+        grid_max = self.config.get("over_under.poisson_grid_max", 6)
+        
+        ou15_thr = self.config.get("over_under.ou15_threshold", 0.55)
+        ou25_thr = self.config.get("over_under.ou25_threshold", 0.52)
+        ou35_thr = self.config.get("over_under.ou35_threshold", 0.48)
+        btts_thr = self.config.get("over_under.btts_threshold", 0.58)
+        
+        # 1. Poisson-based O/U from context xG (team + odds average)
+        p_over_15, p_over_25, p_over_35, p_btts = self._poisson_ou_probs(
+            ctx.home_xg, ctx.away_xg, int(grid_max)
+        )
+        
+        # 2. Odds-based O/U (from odds engine Poisson)
+        o_over_15 = odds_pred.over_15_prob
+        o_over_25 = odds_pred.over_25_prob
+        o_over_35 = odds_pred.over_35_prob
+        o_btts = odds_pred.btts_yes_prob
+        
+        # 3. Blend: poisson xG + odds Poisson
+        # Odds engine already uses Poisson internally, so keep blend weight low
+        # to avoid double-counting. Use majority odds weight for established markets.
+        over_15 = p_over_15 * blend_w + o_over_15 * (1 - blend_w)
+        over_25 = p_over_25 * blend_w + o_over_25 * (1 - blend_w)
+        over_35 = p_over_35 * blend_w + o_over_35 * (1 - blend_w)
+        
+        # BTTS: keep primarily from odds engine (it was 63.6% accurate before)
+        # Only a small Poisson contribution to cross-validate
+        btts_blend = min(blend_w, 0.2)
+        btts_yes = p_btts * btts_blend + o_btts * (1 - btts_blend)
+        
+        # XGBoost Integration (High Weight)
+        w_xgb = self.config.get("xgboost.weight_ou", 0.70)
+        
+        if "ou25" in ctx.xgboost_preds:
+            over_25 = over_25 * (1 - w_xgb) + ctx.xgboost_preds["ou25"] * w_xgb
+            
+        if "ou15" in ctx.xgboost_preds:
+            over_15 = over_15 * (1 - w_xgb) + ctx.xgboost_preds["ou15"] * w_xgb
+            
+        if "ou35" in ctx.xgboost_preds:
+            over_35 = over_35 * (1 - w_xgb) + ctx.xgboost_preds["ou35"] * w_xgb
+            
+        # BTTS: lower XGBoost weight (was 0.70) — Poisson/odds fundamentals matter more
+        w_xgb_btts = self.config.get("xgboost.weight_btts", 0.45)
+        if "btts" in ctx.xgboost_preds:
+            btts_yes = btts_yes * (1 - w_xgb_btts) + ctx.xgboost_preds["btts"] * w_xgb_btts
+        
+        # 4. Referee modifier (only applied to goal totals, not BTTS)
+        ou_mod = referee_mods.get("over_25_modifier", 1.0)
+        over_15 *= ou_mod
+        over_25 *= ou_mod
+        over_35 *= ou_mod
+        
+        # 5. Clamp
+        over_15 = max(prob_min, min(prob_max, over_15))
+        over_25 = max(prob_min, min(prob_max, over_25))
+        over_35 = max(prob_min, min(prob_max, over_35))
+        btts_yes = max(prob_min, min(prob_max, btts_yes))
+        
+        # Picks & Confidence
+        ou15_pick = "Üst 1.5" if over_15 > ou15_thr else "Alt 1.5"
+        ou15_conf = calc_confidence_2way(over_15)
+        
+        ou25_pick = "Üst 2.5" if over_25 > ou25_thr else "Alt 2.5"
+        ou25_conf = calc_confidence_2way(over_25)
+        
+        ou35_pick = "Üst 3.5" if over_35 > ou35_thr else "Alt 3.5"
+        ou35_conf = calc_confidence_2way(over_35)
+        
+        btts_pick = "KG Var" if btts_yes > btts_thr else "KG Yok"
+        btts_conf = calc_confidence_2way(btts_yes)
+        
+        # --- SAFE BTTS PENALTY (v2 — tighter thresholds) ---
+        # Penalize BTTS confidence when fundamentals don't strongly support the pick.
+        try:
+            home_conceded = ctx.team_pred.raw_features.get("home_conceded_avg", 1.0)
+            away_conceded = ctx.team_pred.raw_features.get("away_conceded_avg", 1.0)
+            
+            if btts_pick == "KG Var":
+                # "Var" needs BOTH teams to score → requires strong attack OR leaky defense
+                # Penalty if either xG is low AND defenses are solid
+                weak_attack = ctx.home_xg < 1.30 or ctx.away_xg < 1.15
+                solid_defense = home_conceded < 1.15 or away_conceded < 1.15
+                if weak_attack and solid_defense:
+                    btts_conf *= 0.3
+            else:  # KG Yok
+                # "Yok" needs at least one team to fail scoring
+                # Penalty if both have good xG AND both defenses are leaky
+                if ctx.home_xg >= 1.30 and ctx.away_xg >= 1.15 and home_conceded >= 1.20 and away_conceded >= 1.20:
+                    btts_conf *= 0.3
+                    
+        except Exception as e:
+            print(f"⚠️ Safe BTTS Check Error: {e}")
+            pass
+
+        
+        return OverUnderPrediction(
+            over_15_prob=over_15, under_15_prob=1-over_15,
+            ou15_pick=ou15_pick, ou15_confidence=ou15_conf,
+            
+            over_25_prob=over_25, under_25_prob=1-over_25,
+            ou25_pick=ou25_pick, ou25_confidence=ou25_conf,
+            
+            over_35_prob=over_35, under_35_prob=1-over_35,
+            ou35_pick=ou35_pick, ou35_confidence=ou35_conf,
+            
+            btts_yes_prob=btts_yes, btts_no_prob=1-btts_yes,
+            btts_pick=btts_pick, btts_confidence=btts_conf
+        )
@@ -0,0 +1,289 @@
+from dataclasses import dataclass, field
+from typing import Dict, Any, List, Tuple
+from .base_calculator import BaseCalculator, CalculationContext
+from .odds_anomaly_detector import OddsAnomalyDetector
+
+@dataclass
+class RiskAnalysis:
+    risk_score: float
+    risk_level: str
+    is_surprise_risk: bool
+    reasons: List[str] = field(default_factory=list)
+    surprise_type: str = ""
+    risk_warnings: List[str] = field(default_factory=list)
+
+class RiskAssessor(BaseCalculator):
+    """
+    Assesses risk level of the match based on context and predictions.
+    """
+    
+    def __init__(self, config: Dict):
+        super().__init__(config)
+        self.anomaly_detector = OddsAnomalyDetector(config)
+
+    @staticmethod
+    def _safe_odd(value: Any) -> float:
+        try:
+            odd = float(value)
+            return odd if odd > 1.01 else 0.0
+        except (TypeError, ValueError):
+            return 0.0
+
+    def _favorite_profile_from_odds(self, odds_data: Dict[str, float]) -> Tuple[str, float]:
+        """
+        Returns (favorite_side, gap_to_second_favorite).
+        favorite_side: H, A, D, or U (unknown)
+        """
+        ms_h = self._safe_odd((odds_data or {}).get("ms_h"))
+        ms_d = self._safe_odd((odds_data or {}).get("ms_d"))
+        ms_a = self._safe_odd((odds_data or {}).get("ms_a"))
+
+        candidates = [(side, odd) for side, odd in (("H", ms_h), ("D", ms_d), ("A", ms_a)) if odd > 0.0]
+        if len(candidates) < 2:
+            return "U", 0.0
+
+        candidates.sort(key=lambda item: item[1])
+        favorite_side, favorite_odd = candidates[0]
+        second_odd = candidates[1][1]
+        return favorite_side, max(0.0, second_odd - favorite_odd)
+
+    def _dynamic_reversal_threshold(
+        self,
+        ctx: CalculationContext,
+        top_label: str,
+    ) -> float:
+        """
+        Dynamic threshold for reversal surprise flags.
+        Lower threshold => easier to trigger surprise.
+        """
+        base_threshold = float(self.config.get("risk.surprise_threshold", 0.20))
+        sport_key = (ctx.sport or "football").lower().strip()
+        is_top_league = bool(getattr(ctx, "is_top_league", False))
+
+        if not is_top_league:
+            base_threshold = float(
+                self.config.get("risk.surprise_threshold_non_top", base_threshold + 0.04),
+            )
+
+        if sport_key == "basketball":
+            if is_top_league:
+                top_val = self.config.get("risk.surprise_threshold_basketball_top")
+                if top_val is not None:
+                    return float(top_val)
+                base_val = self.config.get("risk.surprise_threshold_basketball")
+                return float(base_val) if base_val is not None else 0.30
+            
+            non_top_val = self.config.get("risk.surprise_threshold_basketball_non_top")
+            return float(non_top_val) if non_top_val is not None else 0.34
+
+        if top_label not in ("1/2", "2/1"):
+            return base_threshold
+
+        winner_side = "A" if top_label == "1/2" else "H"
+        favorite_side, gap = self._favorite_profile_from_odds(ctx.odds_data)
+
+        if is_top_league:
+            top_fav = self.config.get("risk.surprise_threshold_favorite_reversal_top")
+            if top_fav is not None:
+                favorite_winner_threshold = float(top_fav)
+            else:
+                base_fav = self.config.get("risk.surprise_threshold_favorite_reversal")
+                favorite_winner_threshold = float(base_fav) if base_fav is not None else 0.26
+                
+            top_ud = self.config.get("risk.surprise_threshold_underdog_reversal_top")
+            if top_ud is not None:
+                underdog_winner_threshold = float(top_ud)
+            else:
+                base_ud = self.config.get("risk.surprise_threshold_underdog_reversal")
+                underdog_winner_threshold = float(base_ud) if base_ud is not None else 0.20
+        else:
+            nt_fav = self.config.get("risk.surprise_threshold_favorite_reversal_non_top")
+            favorite_winner_threshold = float(nt_fav) if nt_fav is not None else 0.30
+            nt_ud = self.config.get("risk.surprise_threshold_underdog_reversal_non_top")
+            underdog_winner_threshold = float(nt_ud) if nt_ud is not None else 0.24
+            
+        gm = self.config.get("risk.htft_reversal_gap_medium")
+        gap_medium = float(gm) if gm is not None else 0.50
+        
+        gs = self.config.get("risk.htft_reversal_gap_strong")
+        gap_strong = float(gs) if gs is not None else 1.00
+
+        if favorite_side in ("H", "A"):
+            threshold = (
+                favorite_winner_threshold
+                if winner_side == favorite_side
+                else underdog_winner_threshold
+            )
+            if winner_side != favorite_side and gap >= gap_strong:
+                threshold += 0.03
+            elif winner_side != favorite_side and gap >= gap_medium:
+                threshold += 0.015
+            return threshold
+
+        return base_threshold
+    
+    def calculate(self, ctx: CalculationContext, ms_result: Any = None) -> RiskAnalysis:  # type: ignore[override]
+        """
+        Wrapper for assess_risk to match BaseCalculator interface but with extra arg.
+        """
+        return self.assess_risk(ctx)
+
+    def assess_risk(self, ctx: CalculationContext) -> RiskAnalysis:
+        """
+        Calculate risk score and level.
+        Returns RiskAnalysis object.
+        """
+        score = 5.0
+        reasons = []
+        is_surprise = ctx.is_surprise
+        surprise_type = ""
+        
+        # 1. League deviation (from UpsetEngine)
+        if ctx.is_surprise:
+            score += 2.0
+            reasons.append("High Upset Potential detected by UpsetEngine")
+            
+        # 1.5 Odds Anomaly Detection
+        try:
+            home_conceded = ctx.team_pred.raw_features.get("home_conceded_avg", 1.0)
+            away_conceded = ctx.team_pred.raw_features.get("away_conceded_avg", 1.0)
+            
+            has_anomaly, anomaly_res = self.anomaly_detector.detect_trap(
+                ctx.odds_data, 
+                ctx.home_xg, 
+                ctx.away_xg, 
+                home_conceded, 
+                away_conceded
+            )
+            
+            if has_anomaly:
+                is_surprise = True
+                score += anomaly_res.severity + 2.0
+                surprise_type = "Bookmaker Trap"
+                reasons.append(anomaly_res.reason)
+        except Exception as e:
+            print(f"⚠️ Odds Anomaly Detection Error: {e}")
+            pass
+        
+        # 2. HT/FT Surprise Hunter (XGBoost)
+        # We look for 1/2 (idx 2) and 2/1 (idx 6) from the V20 HT/FT model
+        if "ht_ft" in ctx.xgboost_preds:
+            ht_ft = ctx.xgboost_preds["ht_ft"]
+            valid_items = [(k, float(v)) for k, v in ht_ft.items() if isinstance(v, (int, float))]
+            if valid_items:
+                ranked = sorted(valid_items, key=lambda item: item[1], reverse=True)
+                top_label, top_prob = ranked[0]
+                second_prob = ranked[1][1] if len(ranked) > 1 else 0.0
+                top_gap = top_prob - second_prob
+
+                threshold = self._dynamic_reversal_threshold(ctx, top_label)
+                if getattr(ctx, "is_top_league", False):
+                    top_gap_val = self.config.get("risk.surprise_min_top_gap_top")
+                    if top_gap_val is not None:
+                        min_gap = float(top_gap_val)
+                    else:
+                        base_gap_val = self.config.get("risk.surprise_min_top_gap")
+                        min_gap = float(base_gap_val) if base_gap_val is not None else 0.02
+                else:
+                    non_top_gap_val = self.config.get("risk.surprise_min_top_gap_non_top")
+                    min_gap = float(non_top_gap_val) if non_top_gap_val is not None else 0.03
+
+                # Trigger surprise only when reversal class is:
+                # - top HT/FT outcome
+                # - above dynamic threshold
+                # - separated from second class with a minimum gap
+                if top_label in ("1/2", "2/1") and top_prob > threshold and top_gap > min_gap:
+                    is_surprise = True
+                    score += 3.0
+                    surprise_type = f"{top_label} Reversal"
+                    reasons.append(
+                        f"🔥 Surprise Hunter: {top_label} potential ({round(top_prob*100, 1)}%, gap {round(top_gap*100, 1)}pp)"
+                    )
+                
+                # NEW: Potential Upset Alert - even if reversal is not the top prediction
+                # This catches cases like Bayern vs Augsburg where 1/2 was only 2% but it happened
+                favorite_side, gap = self._favorite_profile_from_odds(ctx.odds_data)
+                
+                # Get reversal probabilities
+                prob_12 = float(ht_ft.get("1/2", 0))
+                prob_21 = float(ht_ft.get("2/1", 0))
+                
+                # DYNAMIC threshold based on odds - stronger favorite = lower threshold
+                # When home odds are 1.30, even 1% reversal probability is significant
+                base_threshold = float(self.config.get("risk.upset_alert_threshold", 0.05))
+                
+                # Calculate dynamic threshold based on favorite strength
+                if favorite_side == "H":
+                    home_odds = float(ctx.odds_data.get("ms_h", 2.0))
+                    # Stronger favorite (lower odds) = lower threshold
+                    # 1.20 odds -> 0.01 threshold, 1.50 odds -> 0.03 threshold, 2.0+ odds -> base threshold
+                    if home_odds <= 1.25:
+                        dynamic_threshold = 0.01  # 1% - extremely strong favorite
+                    elif home_odds <= 1.40:
+                        dynamic_threshold = 0.015  # 1.5% - very strong favorite
+                    elif home_odds <= 1.60:
+                        dynamic_threshold = 0.02  # 2% - strong favorite
+                    elif home_odds < 2.00:
+                        dynamic_threshold = 0.03  # 3% - moderate favorite
+                    else:
+                        dynamic_threshold = base_threshold
+                elif favorite_side == "A":
+                    away_odds = float(ctx.odds_data.get("ms_a", 2.0))
+                    if away_odds <= 1.25:
+                        dynamic_threshold = 0.01
+                    elif away_odds <= 1.40:
+                        dynamic_threshold = 0.015
+                    elif away_odds <= 1.60:
+                        dynamic_threshold = 0.02
+                    elif away_odds < 2.00:
+                        dynamic_threshold = 0.03
+                    else:
+                        dynamic_threshold = base_threshold
+                else:
+                    dynamic_threshold = base_threshold
+                
+                # Check for potential upset based on favorite
+                if favorite_side == "H" and prob_12 > dynamic_threshold:
+                    # Home favorite, but 1/2 (home leads HT, away wins FT) has potential
+                    is_surprise = True
+                    score += 2.0
+                    surprise_type = "1/2 Potential Upset"
+                    reasons.append(
+                        f"⚠️ UPSET ALERT: Home favorite ({ctx.odds_data.get('ms_h', 'N/A')}) but 1/2 reversal risk ({round(prob_12*100, 1)}% > {round(dynamic_threshold*100, 1)}% threshold)"
+                    )
+                elif favorite_side == "A" and prob_21 > dynamic_threshold:
+                    # Away favorite, but 2/1 (away leads HT, home wins FT) has potential
+                    is_surprise = True
+                    score += 2.0
+                    surprise_type = "2/1 Potential Upset"
+                    reasons.append(
+                        f"⚠️ UPSET ALERT: Away favorite ({ctx.odds_data.get('ms_a', 'N/A')}) but 2/1 reversal risk ({round(prob_21*100, 1)}% > {round(dynamic_threshold*100, 1)}% threshold)"
+                    )
+                elif gap > 0.5 and (prob_12 > dynamic_threshold or prob_21 > dynamic_threshold):
+                    # Strong favorite (big odds gap) with any reversal potential
+                    reversal_type = "1/2" if prob_12 > prob_21 else "2/1"
+                    reversal_prob = max(prob_12, prob_21)
+                    is_surprise = True
+                    score += 1.5
+                    surprise_type = f"{reversal_type} Potential Upset"
+                    reasons.append(
+                        f"⚠️ UPSET ALERT: Strong favorite (gap {round(gap, 2)}) with {reversal_type} risk ({round(reversal_prob*100, 1)}%)"
+                    )
+            
+        # Determine level
+        if score < 4.0:
+            level = "LOW"
+        elif score < 7.0:
+            level = "MEDIUM"
+        elif score < 9.0:
+            level = "HIGH"
+        else:
+            level = "EXTREME"
+            
+        return RiskAnalysis(
+            risk_score=score,
+            risk_level=level,
+            is_surprise_risk=is_surprise,
+            surprise_type=surprise_type,
+            reasons=reasons
+        )
@@ -0,0 +1,230 @@
+import os
+import pickle
+import pandas as pd
+import xgboost as xgb
+from dataclasses import dataclass
+from typing import List, Dict, Tuple, Optional
+import math
+from .base_calculator import BaseCalculator, CalculationContext
+from .confidence import calc_confidence_3way, calc_confidence_dc
+from .match_result_calculator import MatchResultPrediction
+
+@dataclass
+class ScorePrediction:
+    predicted_ft_score: str
+    predicted_ht_score: str
+    ft_scores_top5: List[Dict]
+    
+    # Reconciled MS/DC predictions (can be updated here)
+    reconciled_ms: Optional[MatchResultPrediction] = None
+
+class ScoreCalculator(BaseCalculator):
+
+    def __init__(self, config: Dict):
+        super().__init__(config)
+        self.xgb_home = None
+        self.xgb_away = None
+        self.xgb_ht_home = None
+        self.xgb_ht_away = None
+        self.scaler = None # If used
+        self.features = []
+        self._load_model()
+        
+    def _load_model(self):
+        try:
+            model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "models", "xgb_score.pkl")
+            if os.path.exists(model_path):
+                with open(model_path, "rb") as f:
+                    data = pickle.load(f)
+                    # Handle both dictionary and direct model formats (just in case)
+                    if isinstance(data, dict):
+                        self.xgb_home = data.get("home_model")
+                        self.xgb_away = data.get("away_model")
+                        self.xgb_ht_home = data.get("ht_home_model")
+                        self.xgb_ht_away = data.get("ht_away_model")
+                        self.features = data.get("features", [])
+                    else:
+                        print("⚠️ Unexpected XGB score model format.")
+                print("✅ XGBoost Score Model loaded.")
+            else:
+                print(f"⚠️ XGBoost Score Model not found at {model_path}")
+        except Exception as e:
+            print(f"❌ Error loading XGBoost Score Model: {e}")
+
+    def _poisson_pmf(self, k, lam):
+        """Poisson probability mass function."""
+        if lam <= 0:
+            return 1.0 if k == 0 else 0.0
+        return (lam ** k) * math.exp(-lam) / math.factorial(k)
+        
+    def calculate(self, ctx: CalculationContext, ms_result: MatchResultPrediction) -> ScorePrediction:  # type: ignore[override]
+        predicted_ht = None
+        # Default Lambdas (fallback)
+        lambda_home = max(0.5, ctx.home_xg)
+        lambda_away = max(0.5, ctx.away_xg)
+        
+        # --- XGBOOST PREDICTION ---
+        if self.xgb_home and self.xgb_away and hasattr(ctx.team_pred, "raw_features"):
+            try:
+                # 1. Prepare Features
+                # We need to map ctx data to self.features list columns
+                raw = ctx.team_pred.raw_features
+                odds = ctx.odds_data or {}
+                
+                # Use unified feature adapter for exact 56-feature sync
+                from features.feature_adapter import get_feature_adapter
+                df_input = get_feature_adapter().get_features(ctx)
+                
+                # Predict FT
+                pred_h = self.xgb_home.predict(df_input)[0]
+                pred_a = self.xgb_away.predict(df_input)[0]
+                
+                # Predict HT (if available)
+                if self.xgb_ht_home and self.xgb_ht_away:
+                    pred_ht_h = self.xgb_ht_home.predict(df_input)[0]
+                    pred_ht_a = self.xgb_ht_away.predict(df_input)[0]
+                    
+                    # Clamp HT predictions (min 0, and shouldn't exceed FT in logic, but models are independent)
+                    # We trust the model but ensure sanity (HT <= FT is hard to enforce without joint training, but usually holds)
+                    ht_h_val = max(0.0, float(pred_ht_h))
+                    ht_a_val = max(0.0, float(pred_ht_a))
+                    
+                    predicted_ht = f"{round(ht_h_val)}-{round(ht_a_val)}"
+                else:
+                    # Fallback if HT models missing
+                    ht_h_val = max(0.0, float(pred_h) * 0.42)
+                    ht_a_val = max(0.0, float(pred_a) * 0.42)
+                    predicted_ht = f"{round(ht_h_val)}-{round(ht_a_val)}"
+                
+                # Update lambdas with ML predictions
+                lambda_home = max(0.1, min(6.0, float(pred_h)))
+                lambda_away = max(0.1, min(6.0, float(pred_a)))
+                
+                # Store raw XGB preds in context
+                ctx.xgboost_preds["score"] = {
+                    "home": lambda_home, 
+                    "away": lambda_away,
+                    "ht_home": ht_h_val,
+                    "ht_away": ht_a_val
+                }
+                
+            except Exception as e:
+                print(f"⚠️ XGBoost Score Prediction failed: {e}. Falling back to Poisson xG.")
+                # Fallback to current simple logic if ML fails
+                predicted_ht = f"{round(lambda_home * 0.42)}-{round(lambda_away * 0.42)}"
+        
+        # --- POISSON GRID GENERATION ---
+        # Now use lambda_home/away (either ML or fallback) to generate grid
+        score_probs = {}
+        grid_max = self.config.get("score.poisson_grid_max", 7)
+        
+        for i in range(grid_max):
+            for j in range(grid_max):
+                p = self._poisson_pmf(i, lambda_home) * self._poisson_pmf(j, lambda_away)
+                score_probs[f"{i}-{j}"] = round(p * 100, 2)
+        
+        sorted_scores = sorted(score_probs.items(), key=lambda x: x[1], reverse=True)
+        
+        # --- DERIVE MS PROBS FROM SCORES (CONSISTENCY CHECK) ---
+        poisson_ms_home = sum(p for s, p in score_probs.items() 
+                              for h, a in [s.split("-")] if int(h) > int(a))
+        poisson_ms_away = sum(p for s, p in score_probs.items()
+                              for h, a in [s.split("-")] if int(h) < int(a))
+        poisson_ms_draw = sum(p for s, p in score_probs.items()
+                              for h, a in [s.split("-")] if int(h) == int(a))
+        
+        # Normalize
+        poisson_total = poisson_ms_home + poisson_ms_away + poisson_ms_draw
+        if poisson_total > 0:
+            poisson_ms_home /= poisson_total
+            poisson_ms_away /= poisson_total
+            poisson_ms_draw /= poisson_total
+            
+        # --- HYBRID RECONCILIATION ---
+        
+        threshold = self.config.get("score.ms_confidence_threshold", 15.0)
+        reconciled_result = ms_result
+        
+        # If original confidence is low, trust new Score Model more
+        if ms_result.ms_confidence < threshold:
+            poisson_probs = [(poisson_ms_home, "1"), (poisson_ms_draw, "X"), (poisson_ms_away, "2")]
+            poisson_sorted = sorted(poisson_probs, key=lambda x: x[0], reverse=True)
+            
+            new_ms_pick = poisson_sorted[0][1]
+            new_ms_conf = calc_confidence_3way(poisson_sorted[0][0])
+            
+            # Recalculate DC
+            dc_1x = poisson_ms_home + poisson_ms_draw
+            dc_x2 = poisson_ms_draw + poisson_ms_away
+            dc_12 = poisson_ms_home + poisson_ms_away
+            
+            dc_probs = [(dc_1x, "1X"), (dc_x2, "X2"), (dc_12, "12")]
+            dc_sorted = sorted(dc_probs, key=lambda x: x[0], reverse=True)
+            new_dc_pick = dc_sorted[0][1]
+            new_dc_conf = calc_confidence_dc(dc_sorted[0][0])
+            
+            reconciled_result = MatchResultPrediction(
+                ms_home_prob=poisson_ms_home,
+                ms_draw_prob=poisson_ms_draw,
+                ms_away_prob=poisson_ms_away,
+                ms_pick=new_ms_pick,
+                ms_confidence=new_ms_conf,
+                dc_1x_prob=dc_1x,
+                dc_x2_prob=dc_x2,
+                dc_12_prob=dc_12,
+                dc_pick=new_dc_pick,
+                dc_confidence=new_dc_conf
+            )
+            
+        # Select best score that matches MS Pick
+        # NEW LOGIC: We trust XGBoost/Poisson top score over generic MS Pick if MS Confidence is low.
+        # Otherwise, we filter the grid to match the MS pick.
+        ms_pick = reconciled_result.ms_pick
+        
+        def _score_matches_ms(score_str, pick):
+            h, a = map(int, score_str.split("-"))
+            if pick == "1": return h > a
+            if pick == "2": return h < a
+            return h == a
+            
+        matching_scores = [(s, p) for s, p in sorted_scores if _score_matches_ms(s, ms_pick)]
+        
+        # Primary Prediction Strategy:
+        # If MS pick is highly confident, enforce it.
+        # But if the absolute best score in the grid contradicts it and has a high probability (e.g. >10%), trust the score model directly.
+        top_overall_score, top_overall_prob = sorted_scores[0]
+        
+        if matching_scores and not (top_overall_prob > 12.0 and not _score_matches_ms(top_overall_score, ms_pick)):
+            predicted_ft = matching_scores[0][0]
+        else:
+            predicted_ft = top_overall_score
+            
+        # If we didn't calculate HT via ML (exception case), do it now
+        if predicted_ht is None:
+            ft_to_ht = self.config.get("half_time.ft_to_ht_ratio", 0.42)
+            ht_h = round(lambda_home * ft_to_ht)
+            ht_a = round(lambda_away * ft_to_ht)
+            predicted_ht = f"{ht_h}-{ht_a}"
+        
+        # --- CONSISTENCY CHECK ---
+        # Ensure HT score <= FT score
+        try:
+            ft_h, ft_a = map(int, predicted_ft.split("-"))
+            ht_h, ht_a = map(int, predicted_ht.split("-"))
+            
+            # Clamp HT values
+            ht_h = min(ht_h, ft_h)
+            ht_a = min(ht_a, ft_a)
+            
+            predicted_ht = f"{ht_h}-{ht_a}"
+        except ValueError:
+            pass # Malformed score string, ignore correction
+
+        ft_scores = [{"score": s, "prob": p} for s, p in sorted_scores[:5]]
+        
+        return ScorePrediction(
+            predicted_ft_score=predicted_ft,
+            predicted_ht_score=predicted_ht,
+            ft_scores_top5=ft_scores,
+            reconciled_ms=reconciled_result
+        )
@@ -0,0 +1,10 @@
+# ai-engine/core/engines/__init__.py
+"""
+Prediction Engines
+"""
+
+from .player_predictor import PlayerPredictorEngine, get_player_predictor
+
+__all__ = [
+    "PlayerPredictorEngine", "get_player_predictor",
+]
@@ -0,0 +1,359 @@
+"""
+Player Predictor Engine - V20 Ensemble Component
+Analyzes squad quality, key players, and missing player impact.
+
+Weight: 25% in ensemble
+"""
+
+import os
+import sys
+from typing import Dict, Optional, List
+from dataclasses import dataclass
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from features.squad_analysis_engine import get_squad_analysis_engine
+from features.sidelined_analyzer import get_sidelined_analyzer
+
+
+@dataclass
+class PlayerPrediction:
+    """Player engine prediction output.
+
+    IMPORTANT: squad_quality uses the SAME composite formula as
+    extract_training_data.py so that inference values match the
+    distribution the model was trained on (~3-36 range).
+    """
+    home_squad_quality: float = 12.0
+    away_squad_quality: float = 12.0
+    squad_diff: float = 0.0
+    home_key_players: int = 0
+    away_key_players: int = 0
+    home_missing_impact: float = 0.0
+    away_missing_impact: float = 0.0
+    home_goals_form: int = 0
+    away_goals_form: int = 0
+    home_lineup_goals_per90: float = 0.0
+    away_lineup_goals_per90: float = 0.0
+    home_lineup_assists_per90: float = 0.0
+    away_lineup_assists_per90: float = 0.0
+    home_squad_continuity: float = 0.5
+    away_squad_continuity: float = 0.5
+    home_top_scorer_form: int = 0
+    away_top_scorer_form: int = 0
+    home_avg_player_exp: float = 0.0
+    away_avg_player_exp: float = 0.0
+    home_goals_diversity: float = 0.0
+    away_goals_diversity: float = 0.0
+    lineup_available: bool = False
+    confidence: float = 0.0
+
+
+class PlayerPredictorEngine:
+    """
+    Player/Squad-based prediction engine.
+    
+    Analyzes:
+    - Starting 11 quality
+    - Key player availability (top scorers)
+    - Missing player impact
+    - Recent goalscoring form per player
+    """
+    
+    def __init__(self):
+        self.squad_engine = get_squad_analysis_engine()
+        self.sidelined_analyzer = get_sidelined_analyzer()
+        print("✅ PlayerPredictorEngine initialized")
+    
+    def predict(self,
+                match_id: str,
+                home_team_id: str,
+                away_team_id: str,
+                home_lineup: Optional[List[str]] = None,
+                away_lineup: Optional[List[str]] = None,
+                sidelined_data: Optional[Dict] = None) -> PlayerPrediction:
+        """
+        Generate player-based prediction.
+        
+        Args:
+            match_id: Match ID for lineup lookup
+            home_team_id: Home team ID
+            away_team_id: Away team ID
+            home_lineup: Optional list of home player IDs
+            away_lineup: Optional list of away player IDs
+            
+        Returns:
+            PlayerPrediction with squad analysis
+        """
+        
+        # Get squad features
+        home_analysis = None
+        away_analysis = None
+        if home_lineup and away_lineup:
+            home_analysis = self.squad_engine.analyze_squad_from_list(
+                home_lineup, home_team_id
+            )
+            away_analysis = self.squad_engine.analyze_squad_from_list(
+                away_lineup, away_team_id
+            )
+            lineup_available = True
+            features = {
+                "home_starting_11": home_analysis.starting_count or 11,
+                "home_goals_last_5": home_analysis.total_goals_last_5,
+                "home_assists_last_5": home_analysis.total_assists_last_5,
+                "home_key_players": home_analysis.key_players_count,
+                "home_forwards": home_analysis.forward_count or 2,
+                "away_starting_11": away_analysis.starting_count or 11,
+                "away_goals_last_5": away_analysis.total_goals_last_5,
+                "away_assists_last_5": away_analysis.total_assists_last_5,
+                "away_key_players": away_analysis.key_players_count,
+                "away_forwards": away_analysis.forward_count or 2,
+            }
+        elif match_id:
+            try:
+                features = self.squad_engine.get_features(
+                    match_id, home_team_id, away_team_id
+                )
+                lineup_available = (
+                    features.get("home_starting_11", 0) >= 11 and
+                    features.get("away_starting_11", 0) >= 11
+                )
+            except Exception:
+                features = self.squad_engine.get_features_without_match(
+                    home_team_id, away_team_id
+                )
+                lineup_available = False
+        else:
+            features = self.squad_engine.get_features_without_match(
+                home_team_id, away_team_id
+            )
+            lineup_available = False
+
+        home_goals = int(features.get("home_goals_last_5", 0))
+        away_goals = int(features.get("away_goals_last_5", 0))
+        home_key = int(features.get("home_key_players", 0))
+        away_key = int(features.get("away_key_players", 0))
+        home_starting = features.get("home_starting_11", 11)
+        away_starting = features.get("away_starting_11", 11)
+        home_fwd = features.get("home_forwards", 2)
+        away_fwd = features.get("away_forwards", 2)
+
+        # Squad quality — matches V25 extract_training_data.py:579
+        home_quality = home_starting * 0.3 + home_key * 3.0 + home_fwd * 1.5
+        away_quality = away_starting * 0.3 + away_key * 3.0 + away_fwd * 1.5
+        squad_diff = home_quality - away_quality
+
+        # Missing player impact
+        if sidelined_data:
+            home_impact, away_impact = self.sidelined_analyzer.analyze_match(sidelined_data)
+            home_missing = min(1.0, max(0.0, home_impact.impact_score))
+            away_missing = min(1.0, max(0.0, away_impact.impact_score))
+            sidelined_available = True
+        else:
+            expected_xi = 11
+            actual_home_xi = features.get("home_starting_11", 11)
+            actual_away_xi = features.get("away_starting_11", 11)
+            home_missing = (expected_xi - actual_home_xi) / expected_xi if actual_home_xi < expected_xi else 0
+            away_missing = (expected_xi - actual_away_xi) / expected_xi if actual_away_xi < expected_xi else 0
+            sidelined_available = False
+
+        # Player-level features (matches extract_training_data.py:594-650)
+        player_feats = self._compute_player_level_features(
+            home_lineup or [], away_lineup or [],
+            home_team_id, away_team_id,
+            home_analysis, away_analysis,
+        )
+
+        confidence = 70.0 if lineup_available else 35.0
+        if home_goals + away_goals > 10:
+            confidence += 15
+        if sidelined_available:
+            confidence += self.sidelined_analyzer.config.get("sidelined.confidence_boost", 10)
+        if not lineup_available:
+            confidence -= 5.0
+
+        return PlayerPrediction(
+            home_squad_quality=home_quality,
+            away_squad_quality=away_quality,
+            squad_diff=squad_diff,
+            home_key_players=home_key,
+            away_key_players=away_key,
+            home_missing_impact=home_missing,
+            away_missing_impact=away_missing,
+            home_goals_form=home_goals,
+            away_goals_form=away_goals,
+            home_lineup_goals_per90=player_feats['home_lineup_goals_per90'],
+            away_lineup_goals_per90=player_feats['away_lineup_goals_per90'],
+            home_lineup_assists_per90=player_feats['home_lineup_assists_per90'],
+            away_lineup_assists_per90=player_feats['away_lineup_assists_per90'],
+            home_squad_continuity=player_feats['home_squad_continuity'],
+            away_squad_continuity=player_feats['away_squad_continuity'],
+            home_top_scorer_form=player_feats['home_top_scorer_form'],
+            away_top_scorer_form=player_feats['away_top_scorer_form'],
+            home_avg_player_exp=player_feats['home_avg_player_exp'],
+            away_avg_player_exp=player_feats['away_avg_player_exp'],
+            home_goals_diversity=player_feats['home_goals_diversity'],
+            away_goals_diversity=player_feats['away_goals_diversity'],
+            lineup_available=lineup_available,
+            confidence=max(5.0, confidence)
+        )
+
+    def _compute_player_level_features(
+        self,
+        home_lineup: List[str],
+        away_lineup: List[str],
+        home_team_id: str,
+        away_team_id: str,
+        home_analysis,
+        away_analysis,
+    ) -> Dict[str, float]:
+        defaults = {
+            'home_lineup_goals_per90': 0.0, 'away_lineup_goals_per90': 0.0,
+            'home_lineup_assists_per90': 0.0, 'away_lineup_assists_per90': 0.0,
+            'home_squad_continuity': 0.5, 'away_squad_continuity': 0.5,
+            'home_top_scorer_form': 0, 'away_top_scorer_form': 0,
+            'home_avg_player_exp': 0.0, 'away_avg_player_exp': 0.0,
+            'home_goals_diversity': 0.0, 'away_goals_diversity': 0.0,
+        }
+        conn = self.squad_engine.get_conn()
+        if conn is None:
+            return defaults
+
+        try:
+            from psycopg2.extras import RealDictCursor
+            result = {}
+            for prefix, lineup, team_id in [
+                ('home', home_lineup, home_team_id),
+                ('away', away_lineup, away_team_id),
+            ]:
+                if not lineup:
+                    for k in ('lineup_goals_per90', 'lineup_assists_per90',
+                              'squad_continuity', 'top_scorer_form',
+                              'avg_player_exp', 'goals_diversity'):
+                        result[f'{prefix}_{k}'] = defaults[f'{prefix}_{k}']
+                    continue
+
+                g90, a90, total_exp = 0.0, 0.0, 0
+                best_scorer_total, best_scorer_id = 0, None
+                scorers_in_lineup = 0
+
+                with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                    for pid in lineup:
+                        cur.execute("""
+                            SELECT
+                                COUNT(*) as starts,
+                                COALESCE(SUM(CASE WHEN e.event_type = 'goal'
+                                    AND (e.event_subtype IS NULL OR e.event_subtype NOT ILIKE '%%penaltı kaçırma%%')
+                                    THEN 1 ELSE 0 END), 0) as goals,
+                                COALESCE((SELECT COUNT(*) FROM match_player_events
+                                    WHERE assist_player_id = %s), 0) as assists
+                            FROM match_player_participation mpp
+                            LEFT JOIN match_player_events e
+                                ON e.match_id = mpp.match_id AND e.player_id = mpp.player_id
+                            WHERE mpp.player_id = %s AND mpp.is_starting = true
+                        """, (pid, pid))
+                        row = cur.fetchone()
+                        if not row or not row['starts']:
+                            continue
+                        starts = row['starts']
+                        goals = row['goals'] or 0
+                        assists = row['assists'] or 0
+                        g90 += goals / starts
+                        a90 += assists / starts
+                        total_exp += starts
+                        if goals > 0:
+                            scorers_in_lineup += 1
+                        if goals > best_scorer_total:
+                            best_scorer_total = goals
+                            best_scorer_id = pid
+
+                    n_st = len(lineup) or 1
+
+                    # Top scorer recent form (goals in last 5 starts)
+                    top_scorer_form = 0
+                    if best_scorer_id:
+                        cur.execute("""
+                            SELECT COUNT(*) as goals
+                            FROM match_player_events mpe
+                            WHERE mpe.player_id = %s AND mpe.event_type = 'goal'
+                              AND mpe.match_id IN (
+                                  SELECT match_id FROM match_player_participation
+                                  WHERE player_id = %s AND is_starting = true
+                                  ORDER BY match_id DESC LIMIT 5
+                              )
+                        """, (best_scorer_id, best_scorer_id))
+                        tsf_row = cur.fetchone()
+                        if tsf_row:
+                            top_scorer_form = tsf_row['goals'] or 0
+
+                    # Squad continuity (overlap with previous match lineup)
+                    squad_continuity = 0.5
+                    cur.execute("""
+                        SELECT mpp.player_id
+                        FROM match_player_participation mpp
+                        JOIN matches m ON mpp.match_id = m.id
+                        WHERE mpp.team_id = %s AND mpp.is_starting = true
+                          AND m.status = 'FT'
+                        ORDER BY m.mst_utc DESC
+                        LIMIT 11
+                    """, (team_id,))
+                    prev_starters = {r['player_id'] for r in cur.fetchall()}
+                    if prev_starters:
+                        overlap = len(set(lineup) & prev_starters)
+                        squad_continuity = overlap / n_st
+
+                result[f'{prefix}_lineup_goals_per90'] = round(g90, 3)
+                result[f'{prefix}_lineup_assists_per90'] = round(a90, 3)
+                result[f'{prefix}_squad_continuity'] = round(squad_continuity, 3)
+                result[f'{prefix}_top_scorer_form'] = top_scorer_form
+                result[f'{prefix}_avg_player_exp'] = round(total_exp / n_st, 1)
+                result[f'{prefix}_goals_diversity'] = round(scorers_in_lineup / n_st, 3)
+
+            return result
+        except Exception as e:
+            print(f"[PlayerPredictor] Player-level features failed: {e}")
+            return defaults
+    
+    def get_1x2_modifier(self, prediction: PlayerPrediction) -> Dict[str, float]:
+        """
+        Calculate 1X2 probability modifiers based on squad analysis.
+        
+        Returns modifiers to apply to base probabilities.
+        squad_diff is in training scale (~-33 to +33), normalize to -1..+1.
+        """
+        diff = prediction.squad_diff / 33.0  # training-scale normalisation
+        diff = max(-1.0, min(1.0, diff))      # clamp
+        
+        return {
+            "home_modifier": 1.0 + (diff * 0.3),  # Up to +/-30%
+            "away_modifier": 1.0 - (diff * 0.3),
+            "draw_modifier": 1.0 - abs(diff) * 0.2  # Less draw if big diff
+        }
+
+
+# Singleton
+_engine: Optional[PlayerPredictorEngine] = None
+
+
+def get_player_predictor() -> PlayerPredictorEngine:
+    global _engine
+    if _engine is None:
+        _engine = PlayerPredictorEngine()
+    return _engine
+
+
+if __name__ == "__main__":
+    engine = get_player_predictor()
+    
+    print("\n🧪 Player Predictor Engine Test")
+    print("=" * 50)
+    
+    pred = engine.predict(
+        match_id="test_match",
+        home_team_id="test_home",
+        away_team_id="test_away"
+    )
+    
+    print(f"\n📊 Prediction:")
+    for k, v in pred.to_dict().items():
+        print(f"   {k}: {v}")
@@ -0,0 +1,302 @@
+"""
+Quantitative Finance Module — V2 Betting Engine
+Edge calculation, Fractional Kelly Criterion staking, bet grading, and risk assessment.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Any
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Constants
+# ═══════════════════════════════════════════════════════════════════════════
+
+BANKROLL_UNITS: float = 10.0      # Total bankroll in abstract units
+KELLY_FRACTION: float = 0.25     # Quarter-Kelly (conservative, anti-ruin)
+MIN_EDGE_PLAYABLE: float = 0.05  # 5% edge minimum to mark as playable
+MIN_ODDS_PLAYABLE: float = 1.30  # Skip extreme chalk below 1.30
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Edge Calculation
+# ═══════════════════════════════════════════════════════════════════════════
+
+def calculate_edge(true_prob: float, decimal_odds: float) -> float:
+    """
+    Edge = (True_Probability × Decimal_Odds) - 1.0
+    Positive edge → the model says we have an advantage over the bookmaker.
+    """
+    if decimal_odds <= 1.0 or true_prob <= 0.0:
+        return -1.0
+    return round((true_prob * decimal_odds) - 1.0, 4)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Kelly Criterion Staking
+# ═══════════════════════════════════════════════════════════════════════════
+
+def kelly_stake(true_prob: float, decimal_odds: float) -> float:
+    """
+    Fractional Kelly Criterion for a bankroll of BANKROLL_UNITS.
+
+    Full Kelly: f* = ((b × p) - q) / b
+      where b = decimal_odds - 1, p = true_prob, q = 1 - true_prob
+
+    We use KELLY_FRACTION (25%) to reduce variance and avoid ruin.
+    Returns stake in units, rounded to 0.1.
+    """
+    if decimal_odds <= 1.0 or true_prob <= 0.0 or true_prob >= 1.0:
+        return 0.0
+
+    b = decimal_odds - 1.0
+    p = true_prob
+    q = 1.0 - p
+
+    f_star = ((b * p) - q) / b
+
+    if f_star <= 0.0:
+        return 0.0
+
+    # Scale by fraction and bankroll
+    stake = f_star * KELLY_FRACTION * BANKROLL_UNITS
+
+    # Cap at a sensible maximum (3 units on a 10-unit bankroll)
+    stake = min(stake, 3.0)
+
+    return round(max(0.0, stake), 1)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Bet Grading
+# ═══════════════════════════════════════════════════════════════════════════
+
+def grade_bet(edge: float, playable: bool) -> str:
+    """
+    Assign a letter grade based on edge magnitude.
+    A: Edge > 10% — Elite value, rare
+    B: Edge > 5%  — Strong value, core bets
+    C: Edge > 2%  — Marginal value, supporting picks only
+    PASS: Below threshold — Do not bet
+    """
+    if not playable or edge < 0.02:
+        return "PASS"
+    if edge > 0.10:
+        return "A"
+    if edge > 0.05:
+        return "B"
+    return "C"
+
+
+def is_playable(edge: float, decimal_odds: float) -> bool:
+    """A pick is playable if it has sufficient edge AND reasonable odds."""
+    return edge >= MIN_EDGE_PLAYABLE and decimal_odds >= MIN_ODDS_PLAYABLE
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Play Score (0-100 composite)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def calculate_play_score(
+    edge: float,
+    true_prob: float,
+    data_quality: float,
+) -> float:
+    """
+    Composite score combining edge strength, probability confidence,
+    and data quality. Used for ranking picks and filtering.
+
+    Components:
+      - Edge contribution (0-50):  edge * 250, capped at 50
+      - Prob contribution (0-30):  probability * 30
+      - DQ contribution (0-20):    data_quality * 20
+    """
+    edge_score = min(50.0, max(0.0, edge * 250.0))
+    prob_score = min(30.0, max(0.0, true_prob * 30.0))
+    dq_score = min(20.0, max(0.0, data_quality * 20.0))
+    return round(edge_score + prob_score + dq_score, 1)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Risk Assessment
+# ═══════════════════════════════════════════════════════════════════════════
+
+@dataclass
+class RiskResult:
+    level: str          # LOW, MEDIUM, HIGH, EXTREME
+    score: float        # 0.0 - 1.0
+    is_surprise_risk: bool
+    surprise_type: str | None
+    warnings: list[str]
+
+
+def assess_risk(
+    missing_players_impact: float,
+    data_quality_score: float,
+    elo_diff: float,
+    implied_prob_fav: float,
+) -> RiskResult:
+    """
+    Multi-factor risk assessment.
+
+    Factors:
+    1. Missing key players (injuries/suspensions)
+    2. Data quality (missing stats, odds)
+    3. ELO closeness (tight matches are riskier)
+    4. Surprise potential (heavy favorite vulnerable)
+    """
+    warnings: list[str] = []
+    risk_score = 0.0
+
+    # ─── Factor 1: Missing players ────────────────────────────────────
+    if missing_players_impact > 0.3:
+        risk_score += 0.35
+        warnings.append(
+            f"High missing-player impact: {missing_players_impact:.2f}"
+        )
+    elif missing_players_impact > 0.15:
+        risk_score += 0.15
+        warnings.append(
+            f"Moderate missing-player impact: {missing_players_impact:.2f}"
+        )
+
+    # ─── Factor 2: Data quality ───────────────────────────────────────
+    if data_quality_score < 0.5:
+        risk_score += 0.25
+        warnings.append(
+            f"Low data quality: {data_quality_score:.2f}"
+        )
+    elif data_quality_score < 0.75:
+        risk_score += 0.10
+
+    # ─── Factor 3: ELO closeness ──────────────────────────────────────
+    abs_elo_diff = abs(elo_diff)
+    if abs_elo_diff < 50:
+        risk_score += 0.15
+        warnings.append("Very tight ELO difference — coin-flip territory")
+    elif abs_elo_diff < 100:
+        risk_score += 0.05
+
+    # ─── Factor 4: Surprise detection ─────────────────────────────────
+    is_surprise = False
+    surprise_type: str | None = None
+
+    if implied_prob_fav > 0.65 and abs_elo_diff < 80:
+        # Heavy favorite by odds but ELO says match is closer
+        is_surprise = True
+        surprise_type = "odds_elo_divergence"
+        risk_score += 0.15
+        warnings.append(
+            "Upset potential: bookmaker odds suggest heavy favorite "
+            "but ELO says the match is closer than the market thinks"
+        )
+
+    # ─── Classify ─────────────────────────────────────────────────────
+    risk_score = min(1.0, risk_score)
+    if risk_score >= 0.7:
+        level = "EXTREME"
+    elif risk_score >= 0.45:
+        level = "HIGH"
+    elif risk_score >= 0.2:
+        level = "MEDIUM"
+    else:
+        level = "LOW"
+
+    return RiskResult(
+        level=level,
+        score=round(risk_score, 3),
+        is_surprise_risk=is_surprise,
+        surprise_type=surprise_type,
+        warnings=warnings,
+    )
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Market Analysis (orchestrates edge/kelly/grade per market)
+# ═══════════════════════════════════════════════════════════════════════════
+
+@dataclass
+class MarketPick:
+    market: str
+    pick: str
+    probability: float
+    odds: float
+    edge: float
+    playable: bool
+    bet_grade: str
+    stake_units: float
+    play_score: float
+    decision_reasons: list[str]
+
+
+def analyze_market(
+    market: str,
+    probs: dict[str, float],
+    odds_map: dict[str, float],
+    data_quality_score: float,
+) -> MarketPick:
+    """
+    For a given market (MS, OU25, BTTS), find the best pick,
+    calculate edge, kelly stake, and grade it.
+
+    Parameters:
+        market: "MS", "OU25", "BTTS"
+        probs: {"1": 0.55, "X": 0.25, "2": 0.20} — calibrated model probs
+        odds_map: {"1": 2.10, "X": 3.40, "2": 3.50} — decimal odds
+        data_quality_score: 0.0-1.0
+    """
+    best_pick: str = ""
+    best_edge: float = -99.0
+    best_prob: float = 0.0
+    best_odds: float = 0.0
+    reasons: list[str] = []
+
+    for pick_name, prob in probs.items():
+        odd = odds_map.get(pick_name, 0.0)
+        if odd <= 1.0:
+            continue
+
+        edge = calculate_edge(prob, odd)
+        if edge > best_edge:
+            best_edge = edge
+            best_pick = pick_name
+            best_prob = prob
+            best_odds = odd
+
+    if not best_pick:
+        return MarketPick(
+            market=market, pick="", probability=0.0, odds=0.0,
+            edge=0.0, playable=False, bet_grade="PASS",
+            stake_units=0.0, play_score=0.0,
+            decision_reasons=["no_valid_odds_found"],
+        )
+
+    playable = is_playable(best_edge, best_odds)
+    grade = grade_bet(best_edge, playable)
+    stake = kelly_stake(best_prob, best_odds) if playable else 0.0
+    play_score = calculate_play_score(best_edge, best_prob, data_quality_score)
+
+    # Build decision reasons
+    if playable:
+        reasons.append(f"edge_{best_edge:.1%}_above_threshold")
+        reasons.append(f"kelly_stake_{stake:.1f}_units")
+    else:
+        if best_edge < MIN_EDGE_PLAYABLE:
+            reasons.append(f"edge_{best_edge:.1%}_below_{MIN_EDGE_PLAYABLE:.0%}_threshold")
+        if best_odds < MIN_ODDS_PLAYABLE:
+            reasons.append(f"odds_{best_odds:.2f}_below_{MIN_ODDS_PLAYABLE:.2f}_minimum")
+
+    return MarketPick(
+        market=market,
+        pick=best_pick,
+        probability=round(best_prob, 4),
+        odds=round(best_odds, 2),
+        edge=round(best_edge, 4),
+        playable=playable,
+        bet_grade=grade,
+        stake_units=stake,
+        play_score=play_score,
+        decision_reasons=reasons,
+    )
@@ -0,0 +1 @@
+# data package
@@ -0,0 +1,97 @@
+"""
+Async Database Module — V2 Betting Engine
+==========================================
+Provides async SQLAlchemy sessions via asyncpg for the V2 router.
+
+Usage:
+    async with get_session() as session:
+        result = await session.execute(text("SELECT ..."))
+"""
+
+from __future__ import annotations
+
+import os
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+from dotenv import load_dotenv
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+load_dotenv()
+
+_engine: AsyncEngine | None = None
+_session_maker: async_sessionmaker[AsyncSession] | None = None
+
+
+def _get_async_dsn() -> str:
+    """
+    Convert DATABASE_URL to asyncpg-compatible format.
+
+    Handles:
+      1. Prisma's ``?schema=public`` suffix  → stripped
+      2. ``postgresql://`` driver prefix     → ``postgresql+asyncpg://``
+    """
+    dsn = os.getenv(
+        "DATABASE_URL",
+        "postgresql://suggestbet:SuGGesT2026SecuRe@localhost:15432/boilerplate_db",
+    )
+
+    # Strip Prisma's ?schema= parameter
+    if "?" in dsn:
+        base, query = dsn.split("?", 1)
+        kept_parts = [
+            part for part in query.split("&") if part and not part.startswith("schema=")
+        ]
+        dsn = base if not kept_parts else f"{base}?{'&'.join(kept_parts)}"
+
+    # Convert driver prefix for asyncpg
+    if dsn.startswith("postgresql://"):
+        dsn = dsn.replace("postgresql://", "postgresql+asyncpg://", 1)
+    elif dsn.startswith("postgres://"):
+        dsn = dsn.replace("postgres://", "postgresql+asyncpg://", 1)
+
+    return dsn
+
+
+def _ensure_engine() -> AsyncEngine:
+    global _engine, _session_maker
+    if _engine is None:
+        _engine = create_async_engine(
+            _get_async_dsn(),
+            pool_size=5,
+            max_overflow=5,
+            pool_timeout=10,
+            pool_pre_ping=True,
+            echo=False,
+        )
+        _session_maker = async_sessionmaker(
+            bind=_engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+        print("✅ Async database engine created (asyncpg)")
+    return _engine
+
+
+@asynccontextmanager
+async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    """Provide an async session context manager."""
+    _ensure_engine()
+    assert _session_maker is not None
+    async with _session_maker() as session:
+        yield session
+
+
+async def dispose_engine() -> None:
+    """Shut down the async engine cleanly."""
+    global _engine, _session_maker
+    if _engine is not None:
+        await _engine.dispose()
+        _engine = None
+        _session_maker = None
+        print("ℹ️  Async database engine disposed")
@@ -0,0 +1,92 @@
+"""
+Synchronous psycopg2 database helper for the AI Engine.
+Uses a thread-safe connection pool for legacy V20+ endpoints.
+"""
+
+from __future__ import annotations
+
+import os
+from contextlib import contextmanager
+from typing import Generator
+
+import psycopg2
+from psycopg2 import pool
+from psycopg2.extensions import connection as PgConnection
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Safe default with no credentials — will fail fast if not configured.
+_DEFAULT_DSN = "postgresql://postgres:postgres@localhost:15432/boilerplate_db"
+
+
+def get_clean_dsn() -> str:
+    """
+    Return a psycopg2-compatible DSN from DATABASE_URL.
+
+    Handles DSN cleanup issues that break raw usage:
+      1. Prisma appends '?schema=public' which psycopg2 cannot parse.
+    """
+    dsn: str = os.getenv("DATABASE_URL", _DEFAULT_DSN)
+    connect_timeout: str = os.getenv("PGCONNECT_TIMEOUT", "5").strip() or "5"
+
+    # Strip Prisma's ?schema= query parameter while preserving any other query args.
+    if "?" in dsn:
+        base, query = dsn.split("?", 1)
+        kept_parts: list[str] = [
+            part for part in query.split("&") if part and not part.startswith("schema=")
+        ]
+        dsn = base if not kept_parts else f"{base}?{'&'.join(kept_parts)}"
+
+    # Force bounded DB connect attempts so API calls do not hang indefinitely.
+    if "connect_timeout=" not in dsn:
+        separator = "&" if "?" in dsn else "?"
+        dsn = f"{dsn}{separator}connect_timeout={connect_timeout}"
+    return dsn
+
+
+class Database:
+    _pool: pool.ThreadedConnectionPool | None = None
+
+    @classmethod
+    def initialize(cls) -> None:
+        if cls._pool is None:
+            dsn: str = get_clean_dsn()
+            try:
+                cls._pool = pool.ThreadedConnectionPool(
+                    minconn=1,
+                    maxconn=10,
+                    dsn=dsn,
+                )
+                print("✅ Database connection pool created")
+            except Exception as e:
+                print(f"❌ Failed to create DB pool: {e}")
+                raise
+
+    @classmethod
+    def get_conn(cls) -> PgConnection:
+        if cls._pool is None:
+            cls.initialize()
+        assert cls._pool is not None  # guaranteed by initialize()
+        return cls._pool.getconn()
+
+    @classmethod
+    def return_conn(cls, conn: PgConnection) -> None:
+        if cls._pool:
+            cls._pool.putconn(conn)
+
+    @classmethod
+    @contextmanager
+    def connection(cls) -> Generator[PgConnection, None, None]:
+        """Context manager for safe connection handling."""
+        conn: PgConnection = cls.get_conn()
+        try:
+            yield conn
+        finally:
+            cls.return_conn(conn)
+
+    @classmethod
+    def close_all(cls) -> None:
+        if cls._pool:
+            cls._pool.closeall()
+            print("ℹ️  Database connection pool closed")
@@ -0,0 +1,726 @@
+{
+  "version": "v1",
+  "description": "Per-league odds reliability scores computed from Brier Score analysis",
+  "min_matches_threshold": 50,
+  "total_leagues": 265,
+  "default_reliability": 0.35,
+  "lookup": {
+    "bx57cmq1edfq53ckfk791supi": 0.9476,
+    "55hcphd1ccc6eai1ms77460on": 0.9445,
+    "d9eaigzyfnfiraqc3ius757tl": 0.9402,
+    "1gxlzw2ezkyeykhcaa5x8ozkk": 0.9259,
+    "5jd0k2txwnq69frs79eulba8j": 0.9233,
+    "6694fff47wqxl10lrd9tb91f8": 0.9193,
+    "4jg7he1n3rb5dniq6hf49xorq": 0.9061,
+    "59tpnfrwnvhnhzmnvfyug68hj": 0.8988,
+    "ac42gi3penartj88fe9l6plpk": 0.8937,
+    "3j81qr7yc4gdnakfwnxf95ovh": 0.8771,
+    "9z5643nd06afqu01ea2wt8y4g": 0.8734,
+    "482ofyysbdbeoxauk19yg7tdt": 0.8722,
+    "ahl3vljaignq9ebaos4uqkrvo": 0.8696,
+    "8x3sbh85gc8qir50utw39jl04": 0.865,
+    "agpweohvn9tugnyl6ry4rhivp": 0.8428,
+    "4c1nfi2j1m731hcay25fcgndq": 0.8425,
+    "1j4ehtrbry9depwt6oghaq3lu": 0.8299,
+    "40yjcbx2sq6oq736iqqqczwt1": 0.8237,
+    "145hkd59i6foieuwr4mwi6wlq": 0.823,
+    "34pl8szyvrbwcmfkuocjm3r6t": 0.8227,
+    "cse5oqqt2pzfcy8uz6yz3tkbj": 0.8212,
+    "zs18qaehvhg3w1208874zvfa": 0.8176,
+    "57nu0wygurzkp6fuy5hhrtaa2": 0.8099,
+    "1eruend45vd20g9hbrpiggs5u": 0.8083,
+    "595nsvo7ykvoe690b1e4u5n56": 0.7987,
+    "6vq8j5p3av14nr3iuyi4okhjt": 0.793,
+    "486rhdgz7yc0sygziht7hje65": 0.7901,
+    "9hh6n2f84k31zmlcxyvmc1w2y": 0.789,
+    "3n5046abeu3x482ds3jwda238": 0.7863,
+    "8yi6ejjd1zudcqtbn07haahg6": 0.7752,
+    "byhmntnl1b4lxw0zz21im3zkd": 0.7719,
+    "2bmwykmdlcc2u1c40ytoc39vy": 0.7668,
+    "82jkgccg7phfjpd0mltdl3pat": 0.7643,
+    "2nttcoriwf5co73vmz1vr8frm": 0.7641,
+    "dr2xk7muj8aqcjdz2b3li1c0k": 0.759,
+    "4yngyfinzd6bb1k7anqtqs0wt": 0.7586,
+    "eog6knrkfei68si736fpquyzc": 0.756,
+    "eg6s9f1jj7jr6stmbosn0g6c8": 0.7538,
+    "ae1wva3zrzcp2zd15gpvsntg6": 0.7517,
+    "cesdwwnxbc5fmajgroc0hqzy2": 0.7466,
+    "8k1xcsyvxapl4jlsluh3eomre": 0.7463,
+    "bdtat25m14jy85y484z3e6lf": 0.7437,
+    "iu1vi94p4p28oozl1h9bvplr": 0.7411,
+    "1r097lpxe0xn03ihb7wi98kao": 0.7391,
+    "2kwbbcootiqqgmrzs6o5inle5": 0.7386,
+    "9fuwphq8kvugrlc3ckm7k8wes": 0.7358,
+    "civf31q1inxohs4a03y8reetf": 0.735,
+    "ili150pwfuf39f7yfdch9lhw": 0.7286,
+    "abs7n2ae3oydilk0tgmpnsj89": 0.7277,
+    "9nbpdi9q3ywcm4q0j5u0ekwcq": 0.7254,
+    "6by3h89i2eykc341oz7lv1ddd": 0.7252,
+    "4qehj8hfxmy6o2ohp4fxinnzo": 0.7244,
+    "9u4pm8x0lfmfq3r0pypmrls71": 0.7244,
+    "c7b8o53flg36wbuevfzy3lb10": 0.7144,
+    "89ovpy1rarewwzqvi30bfdr8b": 0.7068,
+    "4d5d3sf6805n5u6jdoa0hdlog": 0.7052,
+    "eqz64pn0qsp2y7aq4m9id3fn6": 0.7031,
+    "8q60vlvn3krynkob6igrncdjq": 0.703,
+    "6ihotpaocgiovlxw18e9r9prx": 0.7019,
+    "c0r21rtokgnbtc0o2rldjmkxu": 0.7013,
+    "1mpjd0vbxbtu9zw89yj09xk3z": 0.6996,
+    "4zwgbb66rif2spcoeeol2motx": 0.6995,
+    "bu1l7ckihyr0errxw61p0m05": 0.6995,
+    "cv3tuitw3ho3v0opjjxpn83b9": 0.6974,
+    "8r98daokeuzsamu5fmjtblqx5": 0.6922,
+    "dvstmwnvw0mt5p38twn9yttyb": 0.688,
+    "8y29fg2s85ppcb8uugm5ee8s4": 0.6866,
+    "19q13y6ruzo0o84ipblcuouzs": 0.6858,
+    "f4jc2cc5nq7flaoptpi5ua4k4": 0.6852,
+    "4oogyu6o156iphvdvphwpck10": 0.684,
+    "3e40pestup9xzagsu2o6c0i8u": 0.6824,
+    "4rls982p5uzil6x30mhyhv9f3": 0.6812,
+    "e21cf135btr8t3upw0vl6n6x0": 0.6771,
+    "65q4uwm6ol1rkf5dp89m8omny": 0.6754,
+    "46b141eaqq9q7o4gz5gtdpikk": 0.6752,
+    "75i269i1ak43magshljadydrh": 0.6741,
+    "3ab1uwtoyjopdj1y1fynyy9jg": 0.6737,
+    "4mbfidy8zum5u0aqjqo0vuqs2": 0.673,
+    "7wssxdqi4xihseeam8grqa2b8": 0.666,
+    "61fzfjogstjuukzcehighq7mu": 0.6641,
+    "6g8hw3acenrw828la7gwx4mvs": 0.663,
+    "e1kxdivp5g4cpldgpwvnzl1vv": 0.6626,
+    "9ikchyu9fb8bvx0s673jofj6s": 0.6622,
+    "a9vrdkelbgif0gtu3wxsr75xo": 0.6618,
+    "6sxm2iln2w45ux498pty9miw8": 0.6615,
+    "ea0h6cf3bhl698hkxhpulh2zz": 0.661,
+    "apdwh753fupxheygs8seahh7x": 0.6604,
+    "er5745q30wnr8jv9nr863omzg": 0.659,
+    "2z7257m7hj58zuxcjrsg4erzc": 0.6551,
+    "2o9svokc5s7diish3ycrzk7jm": 0.655,
+    "8usjlmziv3p2re0r2wwzezki9": 0.6549,
+    "c0yqkbilbbg70ij2473xymmqv": 0.6506,
+    "du6jsenbjql5e8f3yk880ox4g": 0.6494,
+    "cbdbziaqczfuyuwqsylqi26zd": 0.6478,
+    "725gd73msyt08xm76v7gkxj7u": 0.6445,
+    "enzlj1as2raqm4ids1zyb07y1": 0.6442,
+    "scf9p4y91yjvqvg5jndxzhxj": 0.6414,
+    "5z8v4mj6cjs9ex6hdrpourjzh": 0.6389,
+    "4zwjlzdszduqmxzusysvzymms": 0.6387,
+    "7nmz249q89qg5ezcvzlheljji": 0.6381,
+    "2mdmx668tyhy4u4z9zszwjv5v": 0.6345,
+    "4a7o9rf7ytl8g3ejwpblc6p5n": 0.6306,
+    "2ty8ihceabty8yddmu31iuuej": 0.6283,
+    "dy8zaksw5e9nwrs1p5ss4o1nu": 0.628,
+    "1b70m6qtxrp75b4vtk8hxh8c3": 0.6261,
+    "ajxs0e0g6ryg5ol8qvw3evrcz": 0.6249,
+    "a4fgj2rfbpf4ejo1qi624fefo": 0.6184,
+    "akmkihra9ruad09ljapsm84b3": 0.6182,
+    "907l7wtxdvugdo9i2249wcmr0": 0.6171,
+    "6lwpjhktjhl9g7x2w7njmzva6": 0.6164,
+    "ax1yf4nlzqpcji4j8epdgx3zl": 0.6163,
+    "6ybvtzejh91761lqe7y1csrqo": 0.6158,
+    "3btdfgw79qiz3jmyfudovtbu2": 0.6122,
+    "5cwsxtx37les6m10xj71htkgf": 0.6101,
+    "9p3nnxhdjahfn8qswpzy8oyc3": 0.61,
+    "2xg0qvif1rh7du6wmk2eleku3": 0.6091,
+    "1wwro3z1eb3fl601dju6inlc6": 0.6084,
+    "gfskxsdituog2kqp9yiu7bzi": 0.6076,
+    "zilopfej2h0n3vpan5tcynpo": 0.6051,
+    "2hsidwomhjsaaytdy9u5niyi4": 0.6012,
+    "1klyfth8tl6lu6ra7k8zmy2n2": 0.5996,
+    "cegl2ivkc25blcatxp4jmk1ec": 0.5993,
+    "7qf0jaayyxy3ruamsexv5p1kl": 0.5988,
+    "erpufio3qaujd9gkszcqvb0bf": 0.5972,
+    "cfesxhzb83yl8b779uv3revz1": 0.597,
+    "3ww12jab49q8q8mk9avdwjqgk": 0.5961,
+    "8t2o4huu2e48ij23dxnl9w5qx": 0.5928,
+    "5vq1bl8h8dxdr34w0jaanokto": 0.5919,
+    "ac112osli9fvox1epcg4ld3t6": 0.59,
+    "3frp1zxrqulrlrnk503n6l4l": 0.5808,
+    "c76z5d6j7dpi1e79tm8fpm39z": 0.5807,
+    "6ifaeunfdelecgticvxanikzu": 0.5796,
+    "81txfenlgw75nq3u2nfdkj92o": 0.5789,
+    "yv73ms6v1995b5wny16jcfi3": 0.5787,
+    "b3ufcd24wfnnd5j98ped6irfu": 0.5752,
+    "29actv1ohj8r10kd9hu0jnb0n": 0.5737,
+    "bfqezwfhot1l3p1cpk4oonh25": 0.5705,
+    "5taraea6mqjjldg9zxswo825y": 0.5696,
+    "7qdv1xae7ikfe8dft3oj29yqc": 0.5692,
+    "dm5ka0os1e3dxcp3vh05kmp33": 0.5678,
+    "ay4u6j7lfkcg7x21mx5q121j": 0.5676,
+    "7af85xa75vozt2l4hzi6ryts7": 0.5663,
+    "5k620c7y6dlbmcm88dt3eb7t": 0.5644,
+    "ejunkmfhjz9weugd2bqrkgobb": 0.564,
+    "3428tckxcirwwh3o3jgc1m8ji": 0.5597,
+    "d6zovb8puwgcmsg91iya6rbtm": 0.5593,
+    "2wolc27r8z03itcvwp43e38c5": 0.5592,
+    "alpfd99yd3lfv7bhjo0biuq7b": 0.5582,
+    "beqqnubkv05mamuwvimeum015": 0.5577,
+    "4w7x0s5gfs5abasphlha5de8k": 0.5558,
+    "9ynnnx1qmkizq1o3qr3v0nsuk": 0.554,
+    "722fdbecxzcq9788l6jqclzlw": 0.5539,
+    "287tckirbfj9nb8ar2k9r60vn": 0.5529,
+    "esrunz7rjb0td98mx9e5cedoy": 0.5516,
+    "32n2r9bl6x90psj0wa7bfs6vq": 0.5487,
+    "50ap4sua1xyut3mpu7ehesp63": 0.5483,
+    "5c96g1zm7vo5ons9c42uy2w3r": 0.5469,
+    "3p81ltz6845appgkbgkzxueii": 0.5454,
+    "3n9mk5b2mxmq831wfmv6pu86i": 0.5437,
+    "5zr0b05eyx25km7z1k03ca9jx": 0.5424,
+    "1owhvvge4wlx7e0e431b4vhqx": 0.5423,
+    "3iwftmprsznl6yribr11a8l9m": 0.5393,
+    "7r1f93t6ddrsa5n8v1nq6qlzm": 0.5393,
+    "1gwajyt0pk2jm5fx5mu36v114": 0.5389,
+    "581t4mywybx21wcpmpykhyzr3": 0.5388,
+    "6wubmo7di3kdpflluf6s8c7vs": 0.5375,
+    "bq89wbdvedtov6auzuh6rsv7s": 0.5363,
+    "byu00jvt1j6csyv4y1lkt2fm2": 0.5359,
+    "af79lqrc0ntom74zq13ccjslo": 0.5357,
+    "3ri6juw2w6ma0jezszdlv1uqm": 0.5356,
+    "3l29w00m506ex93t5bbh9cg2a": 0.5355,
+    "1zp1du9n4rj36p1ss9zbxtqfb": 0.5353,
+    "9chuiarcjofld1dkj9kysehmb": 0.5346,
+    "5aw6uyw4pz2bpj24t5z8aacim": 0.5333,
+    "by5nibd18nkt40t0j8a0j5yzx": 0.5332,
+    "4yzidekywejmxxp77gqmdgopg": 0.5323,
+    "7ntvbsyq31jnzoqoa8850b9b8": 0.5305,
+    "a7247po5qs29o3zsfmt222ydu": 0.5299,
+    "117yqo02rs8dykkxpm274w3bd": 0.5298,
+    "193wqkyb0v5jnsblhvd2ocmyo": 0.5296,
+    "8jh0jejuxfhrpawnoztz2jlv4": 0.5295,
+    "5y0z0l2epprzbscvzsgldw8vu": 0.5288,
+    "47s2kt0e8m444ftqvsrqa3bvq": 0.5268,
+    "2hj3286pqov1g1g59k2t2qcgm": 0.5245,
+    "7swf4kpu3v38i2it4h94c5s9k": 0.5227,
+    "78wml3z5wrfxe5iky50tiotgu": 0.5196,
+    "f39uq10c8xhg5e6rwwcf6lhgc": 0.5186,
+    "bbajzna018c79opa1kl5kmkqo": 0.5172,
+    "4davonpqws4a4ejl1awu98zdg": 0.5168,
+    "1fedahp0rws09tj451onten8r": 0.5163,
+    "aho73e5udydy96iun3tkzdzsi": 0.5149,
+    "3aa4mumjl6zyetg6o9hwd5hhx": 0.5125,
+    "7cwemnr3vi40znjq451zxkus6": 0.5115,
+    "ajm86skyzse4ym8g6fpgzncxa": 0.5112,
+    "bgen5kjer2ytfp7lo9949t72g": 0.5102,
+    "8ey0ww2zsosdmwr8ehsorh6t7": 0.51,
+    "8najqkluatpaxvqws78b9s17c": 0.5082,
+    "8v97rcbthsxmzqk4ufxws9mug": 0.506,
+    "degxm4y6gmvp011ccyrev6z5p": 0.5049,
+    "3oa9e03e7w9nr8kqwqc3tlqz9": 0.5049,
+    "5dycj9wdhxh3n33qubw18ohlk": 0.5036,
+    "3is4bkgf3loxv9qfg3hm8zfqb": 0.5033,
+    "f47f3717z2vtpxfxrpdd4jl1x": 0.498,
+    "8ivsfwex4dfx1tvgsiq8askcx": 0.4972,
+    "8vbck9a4mxjms783lf72779uu": 0.4946,
+    "aql5z4osw5wmun0emnakfpwji": 0.4946,
+    "e6vzdkz6l236s9p288mharefy": 0.4925,
+    "4nidzmunvpvxk1ir9b6m8mpay": 0.4874,
+    "ein4fkggto3pdh5msp8huafiq": 0.4856,
+    "1q4ab2bpg5e8jl1g2udnakrju": 0.4852,
+    "8ztsv3pzrsyq5w1r3a0nfk1y5": 0.4842,
+    "1qd0wvt30rlswa4g6nu4na660": 0.4826,
+    "jznihqxle06xych9ygwiwnsa": 0.4796,
+    "2y8bntiif3a9y6gtmauv30gt": 0.4782,
+    "477yyajzheg2z8u7uick0e13e": 0.4706,
+    "bockl24qpr7ryjl8b6obukga": 0.4671,
+    "7mxwwunvot2pi69pj1yr1kh8i": 0.466,
+    "3w1hkk9k9gr8fwssyn4icvdfo": 0.4657,
+    "1txej2dzohnydl21zc9pgx6hy": 0.464,
+    "b8rae0ib0frjmwlca429bq19q": 0.4624,
+    "b5udgm9vakjqz8dcmy5b2g0xt": 0.4582,
+    "eitf7hulqfv1clb7toewkil24": 0.458,
+    "7hl0svs2hg225i2zud0g3xzp2": 0.4559,
+    "2aso72utuctat2ecs6nahjss6": 0.4521,
+    "3ymqchdzk8tt6lfphf26xfvh0": 0.4519,
+    "2yyjcbbryf1r10apyzl7c7jvp": 0.4507,
+    "bly7ema5au6j40i0grhl0pnub": 0.4476,
+    "b1rveez5u792gess9w3e7v5le": 0.4444,
+    "8sdpk4aerruf515yh76ezo7vi": 0.4434,
+    "32vph7vcjqgo1ksj1548di90n": 0.44,
+    "65ggsqdi6drpa4m8y3gkll25k": 0.4394,
+    "xaouuwuk8qyhv1libkeexwjh": 0.4347,
+    "6qitd9h242qkvjenaytfdnsf2": 0.4312,
+    "duuc1qczfnawwncru1ly6o66": 0.4213,
+    "b60nisd3qn427jm0hrg9kvmab": 0.4203,
+    "xwnjb1az11zffwty3m6vn8y6": 0.4197,
+    "dkarmrybx9vx10rg7cywumth0": 0.4158,
+    "75434tz9rc14xkkvudex742ui": 0.4137,
+    "c1d9p6b2e9zr5tqlzx3ktjplg": 0.4129,
+    "b73zounsynk9d3u1p9nvpu7i2": 0.4049,
+    "913mb508il6jzwtlj28fl892h": 0.4044,
+    "e0lck99w8meo9qoalfrxgo33o": 0.401,
+    "8dn0w8zh7nbn2i904603eigwf": 0.3984,
+    "ddyrh5latwfhesgfh4w401n92": 0.3973,
+    "avs3xposm3t9x1x2vzsoxzcbu": 0.3957,
+    "eu2g5j36zzxiazpd729osx0wm": 0.3924,
+    "67uya58idol2eq18ljecsru5o": 0.3912,
+    "23e698ls3x6vi9x8wl0mz7bsa": 0.3838,
+    "6321dlqv4ziuwqte4xpohijtw": 0.382,
+    "8o5tv5viv4hy1qg9jp94k7ayb": 0.381,
+    "53tknno09wqihmwxrqcuwq9sa": 0.3782,
+    "82wo38rqeizxlfjjhfjy4rx7u": 0.3781,
+    "dvtl8sf1262pd2aqgu641qa7u": 0.3767,
+    "663a54fmymndjeev47qm7d3nf": 0.3522,
+    "macko16888165594668885588": 0.3309,
+    "macko16698982162572521585": 0.3262,
+    "6lkj3o21cr4g7bql6tb3fk222": 0.3261,
+    "cu0rmpyff5692eo06ltddjo8a": 0.3161,
+    "1cnx2c8g3hhp8ssxnwwli0mjb": 0.3121,
+    "4vt0ldrcl6thpxpcs8zmpdq1g": 0.2926,
+    "etta63x1t7tnkn4jheisjwk4p": 0.2907,
+    "1n9l0ex47bu0762qg574hzjtd": 0.2626,
+    "6jgwiu2gq3dllmrwt45pfdn2z": 0.2416,
+    "392slbmf1kdqlr6sd1ckt71rs": 0.24,
+    "8z3180hhw2pj1i65uftlk54uz": 0.2096
+  },
+  "details": [
+    {
+      "league_id": "bx57cmq1edfq53ckfk791supi",
+      "league_name": "CAF Konfederasyon Kupası",
+      "match_count": 98,
+      "brier_score": 0.3046,
+      "heavy_fav_win_pct": 84.1,
+      "fav_win_pct": 63.3,
+      "odds_reliability": 0.9476
+    },
+    {
+      "league_id": "55hcphd1ccc6eai1ms77460on",
+      "league_name": "Şampiyonlar Ligi Kadınlar",
+      "match_count": 89,
+      "brier_score": 0.3258,
+      "heavy_fav_win_pct": 83.3,
+      "fav_win_pct": 74.2,
+      "odds_reliability": 0.9445
+    },
+    {
+      "league_id": "d9eaigzyfnfiraqc3ius757tl",
+      "league_name": "Kupa",
+      "match_count": 78,
+      "brier_score": 0.3141,
+      "heavy_fav_win_pct": 81.2,
+      "fav_win_pct": 73.1,
+      "odds_reliability": 0.9402
+    },
+    {
+      "league_id": "1gxlzw2ezkyeykhcaa5x8ozkk",
+      "league_name": "Concacaf Orta Amerika Kupası",
+      "match_count": 88,
+      "brier_score": 0.3338,
+      "heavy_fav_win_pct": 79.4,
+      "fav_win_pct": 61.4,
+      "odds_reliability": 0.9259
+    },
+    {
+      "league_id": "5jd0k2txwnq69frs79eulba8j",
+      "league_name": "Kupa",
+      "match_count": 69,
+      "brier_score": 0.3223,
+      "heavy_fav_win_pct": 78.4,
+      "fav_win_pct": 66.7,
+      "odds_reliability": 0.9233
+    },
+    {
+      "league_id": "6694fff47wqxl10lrd9tb91f8",
+      "league_name": "Kupa",
+      "match_count": 55,
+      "brier_score": 0.3099,
+      "heavy_fav_win_pct": 78.8,
+      "fav_win_pct": 67.3,
+      "odds_reliability": 0.9193
+    },
+    {
+      "league_id": "4jg7he1n3rb5dniq6hf49xorq",
+      "league_name": "Premier Lig",
+      "match_count": 79,
+      "brier_score": 0.3333,
+      "heavy_fav_win_pct": 77.1,
+      "fav_win_pct": 64.6,
+      "odds_reliability": 0.9061
+    },
+    {
+      "league_id": "59tpnfrwnvhnhzmnvfyug68hj",
+      "league_name": "Libertadores Kupası",
+      "match_count": 180,
+      "brier_score": 0.3408,
+      "heavy_fav_win_pct": 76.2,
+      "fav_win_pct": 61.7,
+      "odds_reliability": 0.8988
+    },
+    {
+      "league_id": "ac42gi3penartj88fe9l6plpk",
+      "league_name": "Premier Lig",
+      "match_count": 185,
+      "brier_score": 0.3148,
+      "heavy_fav_win_pct": 70.7,
+      "fav_win_pct": 68.1,
+      "odds_reliability": 0.8937
+    },
+    {
+      "league_id": "3j81qr7yc4gdnakfwnxf95ovh",
+      "league_name": "Premier Lig",
+      "match_count": 106,
+      "brier_score": 0.333,
+      "heavy_fav_win_pct": 72.2,
+      "fav_win_pct": 60.4,
+      "odds_reliability": 0.8771
+    },
+    {
+      "league_id": "9z5643nd06afqu01ea2wt8y4g",
+      "league_name": "Kuu Bara Ligi",
+      "match_count": 110,
+      "brier_score": 0.3294,
+      "heavy_fav_win_pct": 70.3,
+      "fav_win_pct": 53.6,
+      "odds_reliability": 0.8734
+    },
+    {
+      "league_id": "482ofyysbdbeoxauk19yg7tdt",
+      "league_name": "Trendyol Süper Lig",
+      "match_count": 342,
+      "brier_score": 0.3627,
+      "heavy_fav_win_pct": 80.7,
+      "fav_win_pct": 59.6,
+      "odds_reliability": 0.8722
+    },
+    {
+      "league_id": "ahl3vljaignq9ebaos4uqkrvo",
+      "league_name": "Kupa",
+      "match_count": 105,
+      "brier_score": 0.331,
+      "heavy_fav_win_pct": 70.4,
+      "fav_win_pct": 63.8,
+      "odds_reliability": 0.8696
+    },
+    {
+      "league_id": "8x3sbh85gc8qir50utw39jl04",
+      "league_name": "UEFA Kadınlar Euro 2025 Elemeleri",
+      "match_count": 88,
+      "brier_score": 0.3421,
+      "heavy_fav_win_pct": 75.5,
+      "fav_win_pct": 61.4,
+      "odds_reliability": 0.865
+    },
+    {
+      "league_id": "agpweohvn9tugnyl6ry4rhivp",
+      "league_name": "Eredivisie Kadınlar",
+      "match_count": 51,
+      "brier_score": 0.3356,
+      "heavy_fav_win_pct": 72.0,
+      "fav_win_pct": 56.9,
+      "odds_reliability": 0.8428
+    },
+    {
+      "league_id": "4c1nfi2j1m731hcay25fcgndq",
+      "league_name": "Avrupa Ligi",
+      "match_count": 242,
+      "brier_score": 0.3625,
+      "heavy_fav_win_pct": 77.6,
+      "fav_win_pct": 61.6,
+      "odds_reliability": 0.8425
+    },
+    {
+      "league_id": "1j4ehtrbry9depwt6oghaq3lu",
+      "league_name": "Süper Lig",
+      "match_count": 84,
+      "brier_score": 0.3201,
+      "heavy_fav_win_pct": 65.9,
+      "fav_win_pct": 60.7,
+      "odds_reliability": 0.8299
+    },
+    {
+      "league_id": "40yjcbx2sq6oq736iqqqczwt1",
+      "league_name": "DK Elemeler",
+      "match_count": 88,
+      "brier_score": 0.3383,
+      "heavy_fav_win_pct": 68.6,
+      "fav_win_pct": 55.7,
+      "odds_reliability": 0.8237
+    },
+    {
+      "league_id": "145hkd59i6foieuwr4mwi6wlq",
+      "league_name": "Pro Lig",
+      "match_count": 143,
+      "brier_score": 0.3546,
+      "heavy_fav_win_pct": 73.8,
+      "fav_win_pct": 60.1,
+      "odds_reliability": 0.823
+    },
+    {
+      "league_id": "34pl8szyvrbwcmfkuocjm3r6t",
+      "league_name": "LaLiga",
+      "match_count": 364,
+      "brier_score": 0.3773,
+      "heavy_fav_win_pct": 80.2,
+      "fav_win_pct": 56.6,
+      "odds_reliability": 0.8227
+    },
+    {
+      "league_id": "cse5oqqt2pzfcy8uz6yz3tkbj",
+      "league_name": "CAF Şampiyonlar Ligi",
+      "match_count": 91,
+      "brier_score": 0.3513,
+      "heavy_fav_win_pct": 73.9,
+      "fav_win_pct": 57.1,
+      "odds_reliability": 0.8212
+    },
+    {
+      "league_id": "zs18qaehvhg3w1208874zvfa",
+      "league_name": "1. Lig",
+      "match_count": 225,
+      "brier_score": 0.3744,
+      "heavy_fav_win_pct": 82.1,
+      "fav_win_pct": 59.6,
+      "odds_reliability": 0.8176
+    },
+    {
+      "league_id": "57nu0wygurzkp6fuy5hhrtaa2",
+      "league_name": "1. Lig",
+      "match_count": 286,
+      "brier_score": 0.3626,
+      "heavy_fav_win_pct": 72.9,
+      "fav_win_pct": 59.1,
+      "odds_reliability": 0.8099
+    },
+    {
+      "league_id": "1eruend45vd20g9hbrpiggs5u",
+      "league_name": "Botola Pro",
+      "match_count": 265,
+      "brier_score": 0.3625,
+      "heavy_fav_win_pct": 72.9,
+      "fav_win_pct": 50.2,
+      "odds_reliability": 0.8083
+    },
+    {
+      "league_id": "595nsvo7ykvoe690b1e4u5n56",
+      "league_name": "UEFA Uluslar Ligi",
+      "match_count": 67,
+      "brier_score": 0.3687,
+      "heavy_fav_win_pct": 83.3,
+      "fav_win_pct": 50.7,
+      "odds_reliability": 0.7987
+    },
+    {
+      "league_id": "6vq8j5p3av14nr3iuyi4okhjt",
+      "league_name": "Süper Lig Kadınlar",
+      "match_count": 70,
+      "brier_score": 0.356,
+      "heavy_fav_win_pct": 73.5,
+      "fav_win_pct": 58.6,
+      "odds_reliability": 0.793
+    },
+    {
+      "league_id": "486rhdgz7yc0sygziht7hje65",
+      "league_name": "Kupa",
+      "match_count": 62,
+      "brier_score": 0.3704,
+      "heavy_fav_win_pct": 81.1,
+      "fav_win_pct": 66.1,
+      "odds_reliability": 0.7901
+    },
+    {
+      "league_id": "9hh6n2f84k31zmlcxyvmc1w2y",
+      "league_name": "2. Lig",
+      "match_count": 204,
+      "brier_score": 0.357,
+      "heavy_fav_win_pct": 69.2,
+      "fav_win_pct": 62.3,
+      "odds_reliability": 0.789
+    },
+    {
+      "league_id": "3n5046abeu3x482ds3jwda238",
+      "league_name": "WE Lig Kadınlar",
+      "match_count": 102,
+      "brier_score": 0.3761,
+      "heavy_fav_win_pct": 85.4,
+      "fav_win_pct": 58.8,
+      "odds_reliability": 0.7863
+    },
+    {
+      "league_id": "8yi6ejjd1zudcqtbn07haahg6",
+      "league_name": "Premier Lig",
+      "match_count": 302,
+      "brier_score": 0.3712,
+      "heavy_fav_win_pct": 72.1,
+      "fav_win_pct": 56.3,
+      "odds_reliability": 0.7752
+    },
+    {
+      "league_id": "byhmntnl1b4lxw0zz21im3zkd",
+      "league_name": "Kupa",
+      "match_count": 96,
+      "brier_score": 0.3528,
+      "heavy_fav_win_pct": 68.2,
+      "fav_win_pct": 58.3,
+      "odds_reliability": 0.7719
+    },
+    {
+      "league_id": "2bmwykmdlcc2u1c40ytoc39vy",
+      "league_name": "Açık Kupası",
+      "match_count": 93,
+      "brier_score": 0.3807,
+      "heavy_fav_win_pct": 84.6,
+      "fav_win_pct": 66.7,
+      "odds_reliability": 0.7668
+    },
+    {
+      "league_id": "82jkgccg7phfjpd0mltdl3pat",
+      "league_name": "Süper Lig",
+      "match_count": 289,
+      "brier_score": 0.3782,
+      "heavy_fav_win_pct": 74.0,
+      "fav_win_pct": 57.4,
+      "odds_reliability": 0.7643
+    },
+    {
+      "league_id": "2nttcoriwf5co73vmz1vr8frm",
+      "league_name": "Nesine 2. Lig",
+      "match_count": 525,
+      "brier_score": 0.3782,
+      "heavy_fav_win_pct": 71.8,
+      "fav_win_pct": 55.2,
+      "odds_reliability": 0.7641
+    },
+    {
+      "league_id": "dr2xk7muj8aqcjdz2b3li1c0k",
+      "league_name": "Meistaradeildin",
+      "match_count": 129,
+      "brier_score": 0.3714,
+      "heavy_fav_win_pct": 73.6,
+      "fav_win_pct": 61.2,
+      "odds_reliability": 0.759
+    },
+    {
+      "league_id": "4yngyfinzd6bb1k7anqtqs0wt",
+      "league_name": "Premier Lig",
+      "match_count": 195,
+      "brier_score": 0.3772,
+      "heavy_fav_win_pct": 74.4,
+      "fav_win_pct": 57.4,
+      "odds_reliability": 0.7586
+    },
+    {
+      "league_id": "eog6knrkfei68si736fpquyzc",
+      "league_name": "Lig Kupası",
+      "match_count": 120,
+      "brier_score": 0.3632,
+      "heavy_fav_win_pct": 69.9,
+      "fav_win_pct": 66.7,
+      "odds_reliability": 0.756
+    },
+    {
+      "league_id": "eg6s9f1jj7jr6stmbosn0g6c8",
+      "league_name": "Süper Lig",
+      "match_count": 108,
+      "brier_score": 0.3657,
+      "heavy_fav_win_pct": 71.2,
+      "fav_win_pct": 55.6,
+      "odds_reliability": 0.7538
+    },
+    {
+      "league_id": "ae1wva3zrzcp2zd15gpvsntg6",
+      "league_name": "Ulusal Lig",
+      "match_count": 278,
+      "brier_score": 0.3783,
+      "heavy_fav_win_pct": 72.7,
+      "fav_win_pct": 55.0,
+      "odds_reliability": 0.7517
+    },
+    {
+      "league_id": "cesdwwnxbc5fmajgroc0hqzy2",
+      "league_name": "Hazırlık Maçları Ülkeler",
+      "match_count": 235,
+      "brier_score": 0.3669,
+      "heavy_fav_win_pct": 67.6,
+      "fav_win_pct": 56.2,
+      "odds_reliability": 0.7466
+    },
+    {
+      "league_id": "8k1xcsyvxapl4jlsluh3eomre",
+      "league_name": "Premier Lig",
+      "match_count": 328,
+      "brier_score": 0.385,
+      "heavy_fav_win_pct": 74.2,
+      "fav_win_pct": 45.7,
+      "odds_reliability": 0.7463
+    },
+    {
+      "league_id": "bdtat25m14jy85y484z3e6lf",
+      "league_name": "Kupa",
+      "match_count": 90,
+      "brier_score": 0.3772,
+      "heavy_fav_win_pct": 75.7,
+      "fav_win_pct": 55.6,
+      "odds_reliability": 0.7437
+    },
+    {
+      "league_id": "iu1vi94p4p28oozl1h9bvplr",
+      "league_name": "1. Lig",
+      "match_count": 158,
+      "brier_score": 0.3729,
+      "heavy_fav_win_pct": 71.2,
+      "fav_win_pct": 50.0,
+      "odds_reliability": 0.7411
+    },
+    {
+      "league_id": "1r097lpxe0xn03ihb7wi98kao",
+      "league_name": "Serie A",
+      "match_count": 359,
+      "brier_score": 0.3732,
+      "heavy_fav_win_pct": 67.8,
+      "fav_win_pct": 56.5,
+      "odds_reliability": 0.7391
+    },
+    {
+      "league_id": "2kwbbcootiqqgmrzs6o5inle5",
+      "league_name": "Premier Lig",
+      "match_count": 369,
+      "brier_score": 0.3791,
+      "heavy_fav_win_pct": 70.2,
+      "fav_win_pct": 54.2,
+      "odds_reliability": 0.7386
+    },
+    {
+      "league_id": "9fuwphq8kvugrlc3ckm7k8wes",
+      "league_name": "Ligler Kupası",
+      "match_count": 143,
+      "brier_score": 0.3934,
+      "heavy_fav_win_pct": 81.6,
+      "fav_win_pct": 50.3,
+      "odds_reliability": 0.7358
+    },
+    {
+      "league_id": "civf31q1inxohs4a03y8reetf",
+      "league_name": "Premier Lig",
+      "match_count": 320,
+      "brier_score": 0.3721,
+      "heavy_fav_win_pct": 67.2,
+      "fav_win_pct": 57.8,
+      "odds_reliability": 0.735
+    },
+    {
+      "league_id": "ili150pwfuf39f7yfdch9lhw",
+      "league_name": "UEFA U21 Şampiyonası Elemeler",
+      "match_count": 112,
+      "brier_score": 0.3715,
+      "heavy_fav_win_pct": 70.4,
+      "fav_win_pct": 67.9,
+      "odds_reliability": 0.7286
+    },
+    {
+      "league_id": "abs7n2ae3oydilk0tgmpnsj89",
+      "league_name": "Azadegan Ligi",
+      "match_count": 217,
+      "brier_score": 0.3801,
+      "heavy_fav_win_pct": 71.4,
+      "fav_win_pct": 45.2,
+      "odds_reliability": 0.7277
+    },
+    {
+      "league_id": "9nbpdi9q3ywcm4q0j5u0ekwcq",
+      "league_name": "Serie D",
+      "match_count": 232,
+      "brier_score": 0.3718,
+      "heavy_fav_win_pct": 67.2,
+      "fav_win_pct": 54.7,
+      "odds_reliability": 0.7254
+    }
+  ]
+}
@@ -0,0 +1,29 @@
+"""
+AI Engine V9 Feature Modules
+Includes V8 features + new V9 engines (Upset, Momentum, Poisson, Context, Referee, Squad)
+"""
+
+# V20 Features
+from .h2h_engine import H2HFeatureEngine, get_h2h_engine
+from .elo_system import ELORatingSystem, get_elo_system
+from .value_calculator import ValueCalculator, get_value_calculator
+from .team_stats_engine import get_team_stats_engine
+from .upset_engine import UpsetEngine, get_upset_engine
+from .momentum_engine import MomentumEngine, get_momentum_engine
+from .poisson_engine import PoissonEngine, get_poisson_engine
+from .referee_engine import RefereeEngine, get_referee_engine
+from .squad_analysis_engine import SquadAnalysisEngine, get_squad_analysis_engine
+
+__all__ = [
+    'H2HFeatureEngine', 'get_h2h_engine',
+    'ELORatingSystem', 'get_elo_system',
+    'ValueCalculator', 'get_value_calculator',
+    'get_team_stats_engine',
+    'UpsetEngine', 'get_upset_engine',
+    'MomentumEngine', 'get_momentum_engine',
+    'PoissonEngine', 'get_poisson_engine',
+    'RefereeEngine', 'get_referee_engine',
+    'SquadAnalysisEngine', 'get_squad_analysis_engine',
+]
+
+
@@ -0,0 +1,655 @@
+"""
+ELO Rating System V2 - Venue-Adjusted & League-Weighted
+V9 Model için geliştirilmiş ELO sistemi.
+
+V1'den Farklar:
+- Lig kalitesi faktörü (Premier League vs küçük lig)
+- Form decay (son maçlar daha etkili)
+- Venue-adjusted ELO (ev/deplasman ayrı)
+- Win probability hesaplama
+"""
+
+import os
+import json
+from typing import Dict, Optional, Tuple
+from dataclasses import dataclass, asdict, field
+from datetime import datetime
+
+try:
+    import psycopg2
+except ImportError:
+    psycopg2 = None
+
+MODELS_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'models')
+
+
+@dataclass
+class TeamELO:
+    """Takım ELO profili - Geliştirilmiş"""
+    team_id: str
+    team_name: str = ""
+    
+    # Ana ELO'lar
+    overall_elo: float = 1500.0
+    home_elo: float = 1500.0
+    away_elo: float = 1500.0
+    
+    # Form ELO (son 5 maça göre)
+    form_elo: float = 1500.0
+    
+    # Meta
+    matches_played: int = 0
+    home_matches: int = 0
+    away_matches: int = 0
+    wins: int = 0
+    draws: int = 0
+    losses: int = 0
+    last_updated: Optional[str] = None
+    
+    # Son 5 maç formu (W/D/L sequence)
+    recent_form: str = ""
+    
+    def win_rate(self) -> float:
+        if self.matches_played == 0:
+            return 0.0
+        return self.wins / self.matches_played
+    
+    def to_features(self) -> Dict[str, float]:
+        return {
+            'elo_overall': self.overall_elo,
+            'elo_home': self.home_elo,
+            'elo_away': self.away_elo,
+            'elo_form': self.form_elo,
+            'elo_matches': self.matches_played,
+            'elo_win_rate': self.win_rate(),
+        }
+
+
+# Lig kalitesi faktörleri (1.0 = ortalama)
+LEAGUE_QUALITY = {
+    # Top 5 Avrupa Ligleri
+    "premier league": 1.15,
+    "premier lig": 1.15,
+    "la liga": 1.12,
+    "bundesliga": 1.10,
+    "serie a": 1.08,
+    "ligue 1": 1.05,
+    
+    # Güçlü ligler
+    "eredivisie": 1.02,
+    "primeira liga": 1.02,
+    "süper lig": 1.00,
+    
+    # Avrupa kupaları
+    "champions league": 1.20,
+    "şampiyonlar ligi": 1.20,
+    "europa league": 1.10,
+    "avrupa ligi": 1.10,
+    "conference league": 1.00,
+    
+    # Orta ligler
+    "championship": 0.95,
+    "2. bundesliga": 0.92,
+    "serie b": 0.90,
+    "la liga 2": 0.90,
+    
+    # Küçük ligler
+    "default": 0.85,
+}
+
+
+class ELORatingSystem:
+    """
+    ELO Rating System V2 - Venue-Adjusted & League-Weighted
+    
+    Yenilikler:
+    - Ev/Deplasman ayrı ELO takibi
+    - Lig kalitesi faktörü
+    - Form ELO (son 5 maç ağırlıklı)
+    - Gol farkına göre K-faktör ayarı
+    """
+    
+    # ELO parametreleri
+    K_FACTOR_BASE = 32           # Temel K faktörü
+    K_FACTOR_NEW_TEAM = 48       # Yeni takımlar için daha yüksek (ilk 20 maç)
+    HOME_ADVANTAGE = 65          # Ev sahibi avantajı (ELO cinsinden)
+    INITIAL_ELO = 1500
+    FORM_WEIGHT = 0.7            # Form ELO için son maç ağırlığı
+    
+    def __init__(self):
+        self.ratings: Dict[str, TeamELO] = {}
+        self.league_cache: Dict[str, str] = {}  # team_id -> league_name
+        self.conn = None
+        self._load_ratings()
+    
+    def _connect_db(self):
+        if psycopg2 is None:
+            return None
+        try:
+            from data.db import get_clean_dsn
+            self.conn = psycopg2.connect(get_clean_dsn())
+            return self.conn
+        except Exception as e:
+            print(f"[ELO] DB connection failed: {e}")
+            return None
+    
+    def get_conn(self):
+        if self.conn is None or self.conn.closed:
+            self._connect_db()
+        return self.conn
+    
+    def _load_ratings(self):
+        """Rating'leri yükle — önce DB, sonra JSON fallback"""
+        if self._load_ratings_from_db():
+            return
+        self._load_ratings_from_json()
+
+    def _load_ratings_from_db(self) -> bool:
+        """team_elo_ratings tablosundan rating'leri yükle"""
+        conn = self.get_conn()
+        if conn is None:
+            return False
+        try:
+            cur = conn.cursor()
+            cur.execute("""
+                SELECT ter.team_id, t.name,
+                       ter.overall_elo, ter.home_elo, ter.away_elo,
+                       ter.form_elo, ter.matches_played, ter.recent_form
+                FROM team_elo_ratings ter
+                LEFT JOIN teams t ON ter.team_id = t.id
+            """)
+            rows = cur.fetchall()
+            cur.close()
+            if not rows:
+                return False
+            for row in rows:
+                tid, name, overall, home, away, form, played, recent = row
+                self.ratings[str(tid)] = TeamELO(
+                    team_id=str(tid),
+                    team_name=name or "",
+                    overall_elo=float(overall),
+                    home_elo=float(home),
+                    away_elo=float(away),
+                    form_elo=float(form),
+                    matches_played=int(played),
+                    recent_form=recent or [],
+                )
+            print(f"[OK] ELO V2 ratings DB'den yuklendi ({len(self.ratings)} takim)")
+            return True
+        except Exception as e:
+            print(f"[WARN] ELO DB yuklenemedi, JSON'a dusuyuyor: {e}")
+            return False
+
+    def _load_ratings_from_json(self):
+        """JSON dosyasından rating'leri yükle (fallback)"""
+        ratings_path = os.path.join(MODELS_DIR, 'elo_ratings_v2.json')
+        if os.path.exists(ratings_path):
+            try:
+                with open(ratings_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    for team_id, rating_data in data.items():
+                        self.ratings[team_id] = TeamELO(**rating_data)
+                print(f"[OK] ELO V2 ratings JSON'dan yuklendi ({len(self.ratings)} takim)")
+            except Exception as e:
+                print(f"[WARN] ELO V2 ratings yuklenemedi: {e}")
+    
+    def save_ratings(self):
+        """Rating'leri kaydet"""
+        ratings_path = os.path.join(MODELS_DIR, 'elo_ratings_v2.json')
+        os.makedirs(MODELS_DIR, exist_ok=True)
+        
+        data = {team_id: asdict(elo) for team_id, elo in self.ratings.items()}
+        with open(ratings_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        print(f"💾 ELO V2 ratings kaydedildi ({len(self.ratings)} takım)")
+    
+    def get_or_create_rating(self, team_id: str, team_name: str = "") -> TeamELO:
+        """Takımın ELO'sunu getir veya oluştur"""
+        if team_id not in self.ratings:
+            self.ratings[team_id] = TeamELO(team_id=team_id, team_name=team_name)
+        return self.ratings[team_id]
+    
+    def get_league_quality(self, league_name: str) -> float:
+        """Lig kalitesi faktörünü döndür"""
+        if not league_name:
+            return LEAGUE_QUALITY["default"]
+        
+        league_lower = league_name.lower()
+        for key, quality in LEAGUE_QUALITY.items():
+            if key in league_lower:
+                return quality
+        return LEAGUE_QUALITY["default"]
+    
+    def expected_score(self, rating_a: float, rating_b: float) -> float:
+        """
+        A'nın B'ye karşı beklenen skoru (0-1 arası).
+        1 = kesin kazanır, 0.5 = eşit, 0 = kesin kaybeder
+        """
+        return 1 / (1 + 10 ** ((rating_b - rating_a) / 400))
+    
+    def get_k_factor(self, team_elo: TeamELO, goal_diff: int, 
+                     league_quality: float = 1.0) -> float:
+        """
+        Dinamik K-faktörü hesapla.
+        - Yeni takımlar için yüksek (hızlı adaptasyon)
+        - Gol farkı yüksekse yüksek
+        - Kaliteli liglerde yüksek
+        """
+        # Temel K
+        if team_elo.matches_played < 20:
+            k = self.K_FACTOR_NEW_TEAM
+        else:
+            k = self.K_FACTOR_BASE
+        
+        # Gol farkı çarpanı
+        if goal_diff == 1:
+            goal_mult = 1.0
+        elif goal_diff == 2:
+            goal_mult = 1.25
+        elif goal_diff == 3:
+            goal_mult = 1.5
+        else:
+            goal_mult = 1.75 + (goal_diff - 3) * 0.1
+        
+        # Lig kalitesi çarpanı
+        return k * goal_mult * league_quality
+    
+    def update_after_match(
+        self, 
+        home_id: str, 
+        away_id: str,
+        home_goals: int, 
+        away_goals: int,
+        home_name: str = "",
+        away_name: str = "",
+        league_name: str = ""
+    ):
+        """Maç sonrası ELO güncelle"""
+        home_elo = self.get_or_create_rating(home_id, home_name)
+        away_elo = self.get_or_create_rating(away_id, away_name)
+        
+        # Gerçek skor
+        if home_goals > away_goals:
+            actual_home, actual_away = 1.0, 0.0
+            home_elo.wins += 1
+            away_elo.losses += 1
+            result_home, result_away = 'W', 'L'
+        elif home_goals < away_goals:
+            actual_home, actual_away = 0.0, 1.0
+            home_elo.losses += 1
+            away_elo.wins += 1
+            result_home, result_away = 'L', 'W'
+        else:
+            actual_home, actual_away = 0.5, 0.5
+            home_elo.draws += 1
+            away_elo.draws += 1
+            result_home, result_away = 'D', 'D'
+        
+        goal_diff = abs(home_goals - away_goals)
+        league_quality = self.get_league_quality(league_name)
+        
+        # K faktörleri
+        k_home = self.get_k_factor(home_elo, goal_diff, league_quality)
+        k_away = self.get_k_factor(away_elo, goal_diff, league_quality)
+        
+        # -- Overall ELO --
+        expected_home = self.expected_score(
+            home_elo.overall_elo + self.HOME_ADVANTAGE,
+            away_elo.overall_elo
+        )
+        home_elo.overall_elo += k_home * (actual_home - expected_home)
+        away_elo.overall_elo += k_away * (actual_away - (1 - expected_home))
+        
+        # -- Venue-Specific ELO --
+        expected_home_venue = self.expected_score(home_elo.home_elo, away_elo.away_elo)
+        home_elo.home_elo += k_home * (actual_home - expected_home_venue)
+        away_elo.away_elo += k_away * (actual_away - (1 - expected_home_venue))
+        
+        # -- Form ELO (son maçlar daha ağırlıklı) --
+        home_elo.form_elo = (
+            home_elo.form_elo * (1 - self.FORM_WEIGHT) +
+            (1500 + (actual_home - 0.5) * 100) * self.FORM_WEIGHT
+        )
+        away_elo.form_elo = (
+            away_elo.form_elo * (1 - self.FORM_WEIGHT) +
+            (1500 + (actual_away - 0.5) * 100) * self.FORM_WEIGHT
+        )
+        
+        # Meta güncelle
+        home_elo.matches_played += 1
+        away_elo.matches_played += 1
+        home_elo.home_matches += 1
+        away_elo.away_matches += 1
+        
+        # Son 5 form güncelle
+        home_elo.recent_form = (result_home + home_elo.recent_form)[:5]
+        away_elo.recent_form = (result_away + away_elo.recent_form)[:5]
+        
+        home_elo.last_updated = datetime.now().isoformat()
+        away_elo.last_updated = datetime.now().isoformat()
+    
+    def predict_match(self, home_id: str, away_id: str) -> Dict[str, float]:
+        """
+        Maç için kazanma olasılıklarını tahmin et.
+        """
+        home_elo = self.get_or_create_rating(home_id)
+        away_elo = self.get_or_create_rating(away_id)
+        
+        # Overall bazlı
+        exp_home_overall = self.expected_score(
+            home_elo.overall_elo + self.HOME_ADVANTAGE,
+            away_elo.overall_elo
+        )
+        
+        # Venue bazlı
+        exp_home_venue = self.expected_score(
+            home_elo.home_elo,
+            away_elo.away_elo
+        )
+        
+        # Kombine (ortama)
+        home_prob = (exp_home_overall + exp_home_venue) / 2
+        
+        # Draw tahmini (ELO farkı küçükse daha yüksek)
+        elo_diff = abs(home_elo.overall_elo - away_elo.overall_elo)
+        draw_base = 0.25  # Temel beraberlik oranı
+        draw_prob = draw_base * (1 - elo_diff / 800)  # Fark arttıkça beraberlik azalır
+        draw_prob = max(0.15, min(draw_prob, 0.35))
+        
+        # Normalize
+        remaining = 1 - draw_prob
+        home_win = home_prob * remaining
+        away_win = (1 - home_prob) * remaining
+        
+        return {
+            "home_win": round(home_win, 3),
+            "draw": round(draw_prob, 3),
+            "away_win": round(away_win, 3),
+        }
+    
+    def get_match_features(self, home_id: str, away_id: str) -> Dict[str, float]:
+        """Model için ELO feature'larını döndür"""
+        home_elo = self.get_or_create_rating(home_id)
+        away_elo = self.get_or_create_rating(away_id)
+        
+        probs = self.predict_match(home_id, away_id)
+        
+        # Form encode (WWWDL -> sayısal)
+        def form_to_score(form: str) -> float:
+            if not form:
+                return 0.5
+            score = 0
+            for char in form:
+                if char == 'W':
+                    score += 1
+                elif char == 'D':
+                    score += 0.5
+            return score / max(len(form), 1)
+        
+        return {
+            # Overall ELO
+            'elo_home_overall': home_elo.overall_elo,
+            'elo_away_overall': away_elo.overall_elo,
+            'elo_diff_overall': home_elo.overall_elo - away_elo.overall_elo,
+            
+            # Venue-Specific ELO
+            'elo_home_venue': home_elo.home_elo,
+            'elo_away_venue': away_elo.away_elo,
+            'elo_diff_venue': home_elo.home_elo - away_elo.away_elo,
+            
+            # Form ELO
+            'elo_home_form': home_elo.form_elo,
+            'elo_away_form': away_elo.form_elo,
+            'elo_diff_form': home_elo.form_elo - away_elo.form_elo,
+            
+            # Win probabilities
+            'elo_prob_home': probs['home_win'],
+            'elo_prob_draw': probs['draw'],
+            'elo_prob_away': probs['away_win'],
+            
+            # Experience
+            'elo_home_matches': min(home_elo.matches_played, 100),
+            'elo_away_matches': min(away_elo.matches_played, 100),
+            
+            # Form score
+            'elo_home_form_score': form_to_score(home_elo.recent_form),
+            'elo_away_form_score': form_to_score(away_elo.recent_form),
+            
+            # Win rates
+            'elo_home_win_rate': home_elo.win_rate(),
+            'elo_away_win_rate': away_elo.win_rate(),
+        }
+    
+    def save_ratings_to_db(self):
+        """Rating'leri team_elo_ratings tablosuna yaz (upsert)"""
+        conn = self.get_conn()
+        if conn is None:
+            print("❌ DB bağlantısı yok, DB'ye yazılamadı!")
+            return
+
+        cur = conn.cursor()
+        batch_size = 500
+        teams = list(self.ratings.values())
+        written = 0
+
+        for i in range(0, len(teams), batch_size):
+            batch = teams[i:i + batch_size]
+            values = []
+            for elo in batch:
+                values.append(cur.mogrify(
+                    "(%s, %s, %s, %s, %s, %s, %s, NOW())",
+                    (
+                        elo.team_id,
+                        round(elo.overall_elo, 2),
+                        round(elo.home_elo, 2),
+                        round(elo.away_elo, 2),
+                        round(elo.form_elo, 2),
+                        elo.matches_played,
+                        elo.recent_form[:5],
+                    )
+                ).decode('utf-8'))
+
+            sql = """
+                INSERT INTO team_elo_ratings
+                    (team_id, overall_elo, home_elo, away_elo, form_elo, matches_played, recent_form, updated_at)
+                VALUES {}
+                ON CONFLICT (team_id) DO UPDATE SET
+                    overall_elo    = EXCLUDED.overall_elo,
+                    home_elo       = EXCLUDED.home_elo,
+                    away_elo       = EXCLUDED.away_elo,
+                    form_elo       = EXCLUDED.form_elo,
+                    matches_played = EXCLUDED.matches_played,
+                    recent_form    = EXCLUDED.recent_form,
+                    updated_at     = EXCLUDED.updated_at
+            """.format(", ".join(values))
+
+            cur.execute(sql)
+            written += len(batch)
+
+        conn.commit()
+        cur.close()
+        print(f"💾 DB'ye {written} takım ELO yazıldı (team_elo_ratings)")
+
+    def _load_top_league_ids(self) -> set:
+        """top_leagues.json'dan lig ID'lerini oku"""
+        paths = [
+            os.path.join(os.path.dirname(__file__), '..', '..', 'top_leagues.json'),
+            os.path.join(os.path.dirname(__file__), '..', 'top_leagues.json'),
+        ]
+        for p in paths:
+            if os.path.exists(p):
+                with open(p) as f:
+                    ids = set(json.load(f))
+                    print(f"📋 {len(ids)} top lig yüklendi ({os.path.basename(p)})")
+                    return ids
+        print("⚠️  top_leagues.json bulunamadı — tüm maçlar yazılacak")
+        return set()
+
+    def calculate_all_from_history(self, sport: str = 'football'):
+        """Tüm tarihsel maçlardan ELO hesapla, top ligleri match_ai_features'a yaz"""
+        print(f"\n🔄 {sport.upper()} için ELO V2 hesaplanıyor...")
+
+        conn = self.get_conn()
+        if conn is None:
+            print("❌ DB bağlantısı yok!")
+            return
+
+        top_league_ids = self._load_top_league_ids()
+
+        cur = conn.cursor()
+
+        # Tüm bitmiş maçları tarih sırasına göre al (m.id ve league_id dahil)
+        cur.execute("""
+            SELECT m.id, m.home_team_id, m.away_team_id,
+                   m.score_home, m.score_away, m.league_id,
+                   t1.name as home_name, t2.name as away_name,
+                   l.name as league_name
+            FROM matches m
+            LEFT JOIN teams t1 ON m.home_team_id = t1.id
+            LEFT JOIN teams t2 ON m.away_team_id = t2.id
+            LEFT JOIN leagues l ON m.league_id = l.id
+            WHERE m.sport = %s
+              AND m.score_home IS NOT NULL
+              AND m.score_away IS NOT NULL
+            ORDER BY m.mst_utc ASC
+        """, (sport,))
+
+        matches = cur.fetchall()
+        print(f"📊 {len(matches):,} maç işlenecek...")
+
+        BATCH_SIZE = 1000
+        batch: list = []
+        processed = 0
+        written = 0
+
+        for match in matches:
+            (match_id, home_id, away_id, score_h, score_a,
+             league_id, home_name, away_name, league) = match
+
+            if not (home_id and away_id):
+                continue
+
+            # Sadece top ligler için pre-match ELO kaydet
+            if not top_league_ids or league_id in top_league_ids:
+                home_elo_obj = self.get_or_create_rating(home_id, home_name or "")
+                away_elo_obj = self.get_or_create_rating(away_id, away_name or "")
+                batch.append((
+                    match_id,
+                    home_elo_obj.overall_elo,
+                    away_elo_obj.overall_elo,
+                    home_elo_obj.home_elo,
+                    away_elo_obj.away_elo,
+                    home_elo_obj.form_elo,
+                    away_elo_obj.form_elo,
+                ))
+
+            # Tüm maçlar için ELO güncelle
+            self.update_after_match(
+                home_id, away_id, score_h, score_a,
+                home_name or "", away_name or "", league or ""
+            )
+            processed += 1
+
+            if len(batch) >= BATCH_SIZE:
+                self._flush_elo_batch(cur, batch, sport)
+                conn.commit()
+                written += len(batch)
+                batch.clear()
+
+            if processed % 10000 == 0:
+                print(f"   İşlenen: {processed:,} / {len(matches):,}")
+
+        # Kalan batch'i yaz
+        if batch:
+            self._flush_elo_batch(cur, batch, sport)
+            conn.commit()
+            written += len(batch)
+
+        cur.close()
+        print(f"✅ {processed:,} maç işlendi, {len(self.ratings)} takım")
+        print(f"📝 {written:,} maç match_ai_features'a yazıldı")
+
+        # JSON'a kaydet
+        self.save_ratings()
+
+        # DB'ye kaydet
+        self.save_ratings_to_db()
+
+        # Top 20 takımı göster
+        self._show_top_teams()
+    
+    @staticmethod
+    def _flush_elo_batch(cur, batch: list, sport: str = 'football') -> None:
+        """Batch upsert pre-match ELO values into sport-partitioned ai_features table."""
+        from psycopg2.extras import execute_values
+
+        table_name = 'football_ai_features' if sport == 'football' else 'basketball_ai_features'
+        sql = f"""
+            INSERT INTO {table_name}
+                (match_id, home_elo, away_elo,
+                 home_home_elo, away_away_elo,
+                 home_form_elo, away_form_elo,
+                 calculator_ver, updated_at)
+            VALUES %s
+            ON CONFLICT (match_id) DO UPDATE SET
+                home_elo       = EXCLUDED.home_elo,
+                away_elo       = EXCLUDED.away_elo,
+                home_home_elo  = EXCLUDED.home_home_elo,
+                away_away_elo  = EXCLUDED.away_away_elo,
+                home_form_elo  = EXCLUDED.home_form_elo,
+                away_form_elo  = EXCLUDED.away_form_elo,
+                calculator_ver = EXCLUDED.calculator_ver,
+                updated_at     = EXCLUDED.updated_at
+        """
+        now = datetime.now().isoformat()
+        values = [
+            (mid, h_elo, a_elo, hh_elo, aa_elo, hf_elo, af_elo,
+             'elo_v2_backfill', now)
+            for mid, h_elo, a_elo, hh_elo, aa_elo, hf_elo, af_elo in batch
+        ]
+        execute_values(cur, sql, values, page_size=500)
+
+    def _show_top_teams(self, n: int = 20):
+        """En güçlü takımları göster"""
+        sorted_teams = sorted(
+            self.ratings.items(),
+            key=lambda x: x[1].overall_elo,
+            reverse=True
+        )[:n]
+        
+        print(f"\n🏆 Top {n} Takım (ELO V2):")
+        for i, (team_id, elo) in enumerate(sorted_teams, 1):
+            name = elo.team_name[:25] if elo.team_name else team_id[:25]
+            print(f"   {i:2}. {name:25} → {elo.overall_elo:.0f} (H:{elo.home_elo:.0f} A:{elo.away_elo:.0f})")
+
+
+# Singleton
+_system = None
+
+def get_elo_system() -> ELORatingSystem:
+    global _system
+    if _system is None:
+        _system = ELORatingSystem()
+    return _system
+
+
+if __name__ == "__main__":
+    import sys
+    from pathlib import Path
+
+    # Ensure ai-engine root is on sys.path (for `from data.db import ...`)
+    _AI_ENGINE_ROOT = Path(__file__).resolve().parent.parent
+    if str(_AI_ENGINE_ROOT) not in sys.path:
+        sys.path.insert(0, str(_AI_ENGINE_ROOT))
+    
+    system = get_elo_system()
+    
+    if len(sys.argv) > 1 and sys.argv[1] == 'calculate':
+        system.calculate_all_from_history('football')
+    else:
+        print("\n🧪 ELO V2 Test")
+        print("Kullanım: python elo_system.py calculate")
+        print(f"\n📊 Yüklü takım sayısı: {len(system.ratings)}")
+        
+        if len(system.ratings) > 0:
+            system._show_top_teams(10)
@@ -0,0 +1,990 @@
+"""
+Feature Extractor - V2 Betting Engine
+Pulls historical team stats, ELO, missing-player impact and live odds from
+PostgreSQL and engineers a leakage-free feature vector for the ensemble model.
+
+CRITICAL: Only pre-match data (matches before the target match) is used.
+Post-match stats of the target match are NEVER included.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+import numpy as np
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+logger = logging.getLogger(__name__)
+
+ROLLING_WINDOW: int = 5
+H2H_WINDOW: int = 10
+MAX_REST_DAYS: float = 14.0
+
+
+@dataclass
+class MatchFeatures:
+    """Structured feature vector ready for the ensemble model."""
+
+    match_id: str = ""
+    home_team_id: str = ""
+    away_team_id: str = ""
+
+    # ELO & AI features
+    home_elo: float = 1500.0
+    away_elo: float = 1500.0
+    elo_diff: float = 0.0
+    missing_players_impact: float = 0.0
+    home_form_score: float = 0.0
+    away_form_score: float = 0.0
+    h2h_home_win_rate: float = 0.5
+    h2h_sample_size: int = 0
+    home_rest_days: float = 7.0
+    away_rest_days: float = 7.0
+    rest_diff: float = 0.0
+    home_lineup_availability: float = 1.0
+    away_lineup_availability: float = 1.0
+
+    # Rolling averages - Home (last 5 matches)
+    home_avg_possession: float = 50.0
+    home_avg_shots_on_target: float = 4.0
+    home_avg_total_shots: float = 10.0
+    home_avg_goals_scored: float = 1.3
+    home_avg_goals_conceded: float = 1.1
+
+    # Rolling averages - Away (last 5 matches)
+    away_avg_possession: float = 50.0
+    away_avg_shots_on_target: float = 4.0
+    away_avg_total_shots: float = 10.0
+    away_avg_goals_scored: float = 1.3
+    away_avg_goals_conceded: float = 1.1
+
+    # Implied probabilities from bookmaker odds
+    implied_prob_home: float = 0.33
+    implied_prob_draw: float = 0.33
+    implied_prob_away: float = 0.33
+    implied_prob_over25: float = 0.50
+    implied_prob_under25: float = 0.50
+    implied_prob_btts_yes: float = 0.50
+    implied_prob_btts_no: float = 0.50
+
+    # Raw decimal odds (for Edge/Kelly calculations downstream)
+    odds_home: float = 2.50
+    odds_draw: float = 3.20
+    odds_away: float = 2.80
+    odds_over25: float = 1.90
+    odds_under25: float = 1.90
+    odds_btts_yes: float = 1.85
+    odds_btts_no: float = 1.95
+
+    # Data quality
+    data_quality_score: float = 0.5
+    data_quality_flags: list[str] = field(default_factory=list)
+
+    # Metadata
+    match_name: str = ""
+    home_team_name: str = ""
+    away_team_name: str = ""
+    league_id: str = ""
+    league_name: str = ""
+    referee_name: str = ""
+    match_date_ms: int = 0
+    league_avg_goals: float = 2.6
+    referee_avg_goals: float = 2.6
+    referee_home_bias: float = 0.0
+    home_squad_strength: float = 0.5
+    away_squad_strength: float = 0.5
+    home_key_players: float = 0.0
+    away_key_players: float = 0.0
+
+    def to_model_array(self) -> np.ndarray:
+        """Return the 24-feature vector the ensemble expects."""
+        return np.array(
+            [
+                self.home_elo,
+                self.away_elo,
+                self.elo_diff,
+                self.missing_players_impact,
+                self.home_avg_possession,
+                self.home_avg_shots_on_target,
+                self.home_avg_total_shots,
+                self.home_avg_goals_scored,
+                self.home_avg_goals_conceded,
+                self.away_avg_possession,
+                self.away_avg_shots_on_target,
+                self.away_avg_total_shots,
+                self.away_avg_goals_scored,
+                self.away_avg_goals_conceded,
+                self.implied_prob_home,
+                self.implied_prob_draw,
+                self.implied_prob_away,
+                self.implied_prob_over25,
+                self.implied_prob_under25,
+                self.implied_prob_btts_yes,
+                self.implied_prob_btts_no,
+                self.odds_home,
+                self.odds_draw,
+                self.odds_away,
+            ],
+            dtype=np.float64,
+        )
+
+    @staticmethod
+    def feature_names() -> list[str]:
+        return [
+            "home_elo", "away_elo", "elo_diff", "missing_players_impact",
+            "home_avg_possession", "home_avg_shots_on_target",
+            "home_avg_total_shots", "home_avg_goals_scored",
+            "home_avg_goals_conceded",
+            "away_avg_possession", "away_avg_shots_on_target",
+            "away_avg_total_shots", "away_avg_goals_scored",
+            "away_avg_goals_conceded",
+            "implied_prob_home", "implied_prob_draw", "implied_prob_away",
+            "implied_prob_over25", "implied_prob_under25",
+            "implied_prob_btts_yes", "implied_prob_btts_no",
+            "odds_home", "odds_draw", "odds_away",
+        ]
+
+
+async def extract_features(session: AsyncSession, match_id: str) -> MatchFeatures | None:
+    """Master extraction pipeline."""
+    feats = MatchFeatures(match_id=match_id)
+    flags: list[str] = []
+
+    match_row = await _load_match_header(session, match_id)
+    if match_row is None:
+        logger.warning("Match %s not found in live_matches or matches.", match_id)
+        return None
+
+    feats.home_team_id = match_row["home_team_id"] or ""
+    feats.away_team_id = match_row["away_team_id"] or ""
+    feats.match_name = match_row.get("match_name", "") or ""
+    feats.match_date_ms = int(match_row.get("mst_utc", 0) or 0)
+    feats.home_team_name = match_row.get("home_name", "") or ""
+    feats.away_team_name = match_row.get("away_name", "") or ""
+    feats.league_id = match_row.get("league_id", "") or ""
+    feats.league_name = match_row.get("league_name", "") or ""
+    feats.referee_name = match_row.get("referee_name", "") or ""
+
+    if not feats.home_team_id or not feats.away_team_id:
+        logger.warning("Match %s missing team IDs.", match_id)
+        flags.append("missing_team_ids")
+        feats.data_quality_flags = flags
+        feats.data_quality_score = 0.1
+        return feats
+
+    ai_row = await _load_ai_features(session, match_id)
+    if ai_row:
+        feats.home_elo = float(ai_row["home_elo"] or 1500.0)
+        feats.away_elo = float(ai_row["away_elo"] or 1500.0)
+        feats.missing_players_impact = float(ai_row["missing_players_impact"] or 0.0)
+        feats.home_form_score = float(ai_row["home_form_score"] or 0.0)
+        feats.away_form_score = float(ai_row["away_form_score"] or 0.0)
+        if ai_row.get("h2h_home_win_rate") is not None:
+            feats.h2h_home_win_rate = float(ai_row["h2h_home_win_rate"])
+            feats.h2h_sample_size = int(ai_row.get("h2h_total") or 0)
+    else:
+        flags.append("missing_ai_features")
+
+    feats.elo_diff = feats.home_elo - feats.away_elo
+
+    home_rolling = await _rolling_team_stats(
+        session, feats.home_team_id, feats.match_date_ms,
+    )
+    away_rolling = await _rolling_team_stats(
+        session, feats.away_team_id, feats.match_date_ms,
+    )
+
+    if home_rolling is not None:
+        feats.home_avg_possession = home_rolling["avg_possession"]
+        feats.home_avg_shots_on_target = home_rolling["avg_shots_on_target"]
+        feats.home_avg_total_shots = home_rolling["avg_total_shots"]
+        feats.home_avg_goals_scored = home_rolling["avg_goals_scored"]
+        feats.home_avg_goals_conceded = home_rolling["avg_goals_conceded"]
+    else:
+        flags.append("missing_home_stats")
+
+    if away_rolling is not None:
+        feats.away_avg_possession = away_rolling["avg_possession"]
+        feats.away_avg_shots_on_target = away_rolling["avg_shots_on_target"]
+        feats.away_avg_total_shots = away_rolling["avg_total_shots"]
+        feats.away_avg_goals_scored = away_rolling["avg_goals_scored"]
+        feats.away_avg_goals_conceded = away_rolling["avg_goals_conceded"]
+    else:
+        flags.append("missing_away_stats")
+
+    if abs(feats.home_form_score) < 1e-6:
+        feats.home_form_score = round(
+            feats.home_avg_goals_scored - feats.home_avg_goals_conceded,
+            3,
+        )
+    if abs(feats.away_form_score) < 1e-6:
+        feats.away_form_score = round(
+            feats.away_avg_goals_scored - feats.away_avg_goals_conceded,
+            3,
+        )
+
+    home_rest_days = await _load_rest_days(
+        session, feats.home_team_id, feats.match_date_ms,
+    )
+    away_rest_days = await _load_rest_days(
+        session, feats.away_team_id, feats.match_date_ms,
+    )
+    if home_rest_days is not None:
+        feats.home_rest_days = home_rest_days
+    else:
+        flags.append("missing_home_rest")
+    if away_rest_days is not None:
+        feats.away_rest_days = away_rest_days
+    else:
+        flags.append("missing_away_rest")
+    feats.rest_diff = round(feats.home_rest_days - feats.away_rest_days, 3)
+
+    if feats.h2h_sample_size == 0:
+        h2h = await _load_h2h_stats(
+            session,
+            feats.home_team_id,
+            feats.away_team_id,
+            feats.match_date_ms,
+        )
+        if h2h is not None:
+            feats.h2h_home_win_rate = h2h["home_win_rate"]
+            feats.h2h_sample_size = h2h["sample_size"]
+        else:
+            flags.append("missing_h2h")
+
+    league_profile = await _load_league_profile(
+        session,
+        feats.league_id,
+        feats.match_date_ms,
+    )
+    if league_profile is not None:
+        feats.league_avg_goals = league_profile["avg_goals"]
+    else:
+        flags.append("missing_league_profile")
+
+    referee_profile = await _load_referee_profile(
+        session,
+        feats.referee_name,
+        feats.match_date_ms,
+    )
+    if referee_profile is not None:
+        feats.referee_avg_goals = referee_profile["avg_goals"]
+        feats.referee_home_bias = referee_profile["home_bias"]
+    else:
+        flags.append("missing_referee_profile")
+
+    home_squad = await _load_team_squad_profile(
+        session,
+        feats.home_team_id,
+        feats.match_date_ms,
+    )
+    away_squad = await _load_team_squad_profile(
+        session,
+        feats.away_team_id,
+        feats.match_date_ms,
+    )
+    if home_squad is not None:
+        feats.home_squad_strength = home_squad["squad_strength"]
+        feats.home_key_players = home_squad["key_players"]
+    else:
+        flags.append("missing_home_squad_profile")
+    if away_squad is not None:
+        feats.away_squad_strength = away_squad["squad_strength"]
+        feats.away_key_players = away_squad["key_players"]
+    else:
+        flags.append("missing_away_squad_profile")
+
+    lineup_info = _extract_lineup_context(match_row)
+    feats.home_lineup_availability = lineup_info["home_availability"]
+    feats.away_lineup_availability = lineup_info["away_availability"]
+    if lineup_info["has_real_lineup_data"]:
+        feats.missing_players_impact = max(
+            feats.missing_players_impact,
+            round(
+                (
+                    (1.0 - feats.home_lineup_availability)
+                    + (1.0 - feats.away_lineup_availability)
+                ) / 2.0,
+                4,
+            ),
+        )
+    else:
+        flags.append("missing_lineup_context")
+
+    odds_ok = await _extract_odds(session, match_id, feats)
+    if not odds_ok:
+        flags.append("missing_odds")
+
+    quality = 1.0
+    penalty_map = {
+        "missing_team_ids": 0.5,
+        "missing_ai_features": 0.05,
+        "missing_home_stats": 0.15,
+        "missing_away_stats": 0.15,
+        "missing_home_rest": 0.05,
+        "missing_away_rest": 0.05,
+        "missing_h2h": 0.05,
+        "missing_league_profile": 0.04,
+        "missing_referee_profile": 0.04,
+        "missing_home_squad_profile": 0.06,
+        "missing_away_squad_profile": 0.06,
+        "missing_lineup_context": 0.05,
+        "missing_odds": 0.2,
+    }
+    for flag in flags:
+        quality -= penalty_map.get(flag, 0.05)
+    feats.data_quality_score = max(0.0, round(quality, 2))
+    feats.data_quality_flags = flags
+
+    return feats
+
+
+async def _load_match_header(
+    session: AsyncSession, match_id: str,
+) -> dict[str, Any] | None:
+    """Try live_matches first, then matches table."""
+    table_queries = {
+        "live_matches": """
+            SELECT
+                m.id,
+                m.home_team_id,
+                m.away_team_id,
+                m.match_name,
+                m.mst_utc,
+                m.sport,
+                m.league_id,
+                m.referee_name,
+                m.lineups,
+                m.sidelined,
+                ht.name AS home_name,
+                at.name AS away_name,
+                l.name AS league_name
+            FROM live_matches m
+            LEFT JOIN teams ht ON ht.id = m.home_team_id
+            LEFT JOIN teams at ON at.id = m.away_team_id
+            LEFT JOIN leagues l ON l.id = m.league_id
+            WHERE m.id = :match_id
+            LIMIT 1
+        """,
+        "matches": """
+            SELECT
+                m.id,
+                m.home_team_id,
+                m.away_team_id,
+                m.match_name,
+                m.mst_utc,
+                m.sport,
+                m.league_id,
+                ref.name AS referee_name,
+                NULL AS lineups,
+                NULL AS sidelined,
+                ht.name AS home_name,
+                at.name AS away_name,
+                l.name AS league_name
+            FROM matches m
+            LEFT JOIN teams ht ON ht.id = m.home_team_id
+            LEFT JOIN teams at ON at.id = m.away_team_id
+            LEFT JOIN leagues l ON l.id = m.league_id
+            LEFT JOIN match_officials ref ON ref.match_id = m.id AND ref.role_id = 1
+            WHERE m.id = :match_id
+            LIMIT 1
+        """,
+    }
+    for table in ("live_matches", "matches"):
+        query = text(table_queries[table])
+        result = await session.execute(query, {"match_id": match_id})
+        row = result.mappings().first()
+        if row:
+            return dict(row)
+    return None
+
+
+async def _load_ai_features(
+    session: AsyncSession, match_id: str,
+) -> dict[str, Any] | None:
+    query = text("""
+        SELECT
+            home_elo,
+            away_elo,
+            missing_players_impact,
+            home_form_score,
+            away_form_score,
+            h2h_home_win_rate,
+            h2h_total
+        FROM football_ai_features
+        WHERE match_id = :match_id
+        LIMIT 1
+    """)
+    result = await session.execute(query, {"match_id": match_id})
+    row = result.mappings().first()
+    return dict(row) if row else None
+
+
+async def _rolling_team_stats(
+    session: AsyncSession,
+    team_id: str,
+    before_mst_utc: int,
+) -> dict[str, float] | None:
+    """Calculate rolling averages from the team's last N finished matches."""
+    query = text("""
+        WITH recent AS (
+            SELECT
+                m.id AS match_id,
+                m.home_team_id,
+                m.away_team_id,
+                m.score_home,
+                m.score_away,
+                ts.possession_percentage,
+                ts.shots_on_target,
+                ts.total_shots
+            FROM matches m
+            JOIN football_team_stats ts ON ts.match_id = m.id AND ts.team_id = :team_id
+            WHERE (m.home_team_id = :team_id OR m.away_team_id = :team_id)
+              AND m.mst_utc < :before_ts
+              AND m.sport = 'football'
+              AND m.score_home IS NOT NULL
+              AND m.score_away IS NOT NULL
+            ORDER BY m.mst_utc DESC
+            LIMIT :window
+        )
+        SELECT
+            COALESCE(AVG(possession_percentage), 50.0) AS avg_possession,
+            COALESCE(AVG(shots_on_target), 4.0) AS avg_shots_on_target,
+            COALESCE(AVG(total_shots), 10.0) AS avg_total_shots,
+            COALESCE(AVG(
+                CASE
+                    WHEN home_team_id = :team_id THEN score_home
+                    ELSE score_away
+                END
+            ), 1.3) AS avg_goals_scored,
+            COALESCE(AVG(
+                CASE
+                    WHEN home_team_id = :team_id THEN score_away
+                    ELSE score_home
+                END
+            ), 1.1) AS avg_goals_conceded,
+            COUNT(*) AS match_count
+        FROM recent
+    """)
+    result = await session.execute(
+        query,
+        {"team_id": team_id, "before_ts": before_mst_utc, "window": ROLLING_WINDOW},
+    )
+    row = result.mappings().first()
+    if row is None or int(row["match_count"]) == 0:
+        return None
+    return {
+        "avg_possession": round(float(row["avg_possession"]), 2),
+        "avg_shots_on_target": round(float(row["avg_shots_on_target"]), 2),
+        "avg_total_shots": round(float(row["avg_total_shots"]), 2),
+        "avg_goals_scored": round(float(row["avg_goals_scored"]), 2),
+        "avg_goals_conceded": round(float(row["avg_goals_conceded"]), 2),
+    }
+
+
+async def _load_rest_days(
+    session: AsyncSession,
+    team_id: str,
+    before_mst_utc: int,
+) -> float | None:
+    query = text("""
+        SELECT m.mst_utc
+        FROM matches m
+        WHERE (m.home_team_id = :team_id OR m.away_team_id = :team_id)
+          AND m.mst_utc < :before_ts
+          AND m.sport = 'football'
+        ORDER BY m.mst_utc DESC
+        LIMIT 1
+    """)
+    result = await session.execute(
+        query,
+        {"team_id": team_id, "before_ts": before_mst_utc},
+    )
+    last_match_ts = result.scalar_one_or_none()
+    if last_match_ts is None:
+        return None
+
+    rest_days = max(0.0, (float(before_mst_utc) - float(last_match_ts)) / 86400000.0)
+    return round(min(rest_days, MAX_REST_DAYS), 3)
+
+
+async def _load_h2h_stats(
+    session: AsyncSession,
+    home_team_id: str,
+    away_team_id: str,
+    before_mst_utc: int,
+) -> dict[str, float | int] | None:
+    query = text("""
+        SELECT
+            m.home_team_id,
+            m.away_team_id,
+            m.score_home,
+            m.score_away
+        FROM matches m
+        WHERE m.sport = 'football'
+          AND m.mst_utc < :before_ts
+          AND m.score_home IS NOT NULL
+          AND m.score_away IS NOT NULL
+          AND (
+            (m.home_team_id = :home_team_id AND m.away_team_id = :away_team_id)
+            OR
+            (m.home_team_id = :away_team_id AND m.away_team_id = :home_team_id)
+          )
+        ORDER BY m.mst_utc DESC
+        LIMIT :window
+    """)
+    result = await session.execute(
+        query,
+        {
+            "home_team_id": home_team_id,
+            "away_team_id": away_team_id,
+            "before_ts": before_mst_utc,
+            "window": H2H_WINDOW,
+        },
+    )
+    rows = result.mappings().all()
+    if not rows:
+        return None
+
+    home_wins = 0.0
+    draws = 0.0
+    sample_size = 0
+    for row in rows:
+        score_home = row["score_home"]
+        score_away = row["score_away"]
+        if score_home is None or score_away is None:
+            continue
+        sample_size += 1
+        row_home_team_id = row["home_team_id"]
+        row_away_team_id = row["away_team_id"]
+
+        current_home_score = float(score_home) if row_home_team_id == home_team_id else float(score_away)
+        current_away_score = float(score_away) if row_home_team_id == home_team_id else float(score_home)
+
+        if current_home_score > current_away_score:
+            home_wins += 1.0
+        elif current_home_score == current_away_score:
+            draws += 1.0
+
+    if sample_size == 0:
+        return None
+
+    # Count draws as a half-win signal instead of throwing them away.
+    home_win_rate = round((home_wins + draws * 0.5) / sample_size, 4)
+    return {
+        "home_win_rate": home_win_rate,
+        "sample_size": sample_size,
+    }
+
+
+async def _load_league_profile(
+    session: AsyncSession,
+    league_id: str,
+    before_mst_utc: int,
+) -> dict[str, float] | None:
+    if not league_id:
+        return None
+
+    query = text("""
+        SELECT
+            COALESCE(AVG(m.score_home + m.score_away), 2.6) AS avg_goals,
+            COUNT(*) AS match_count
+        FROM (
+            SELECT score_home, score_away
+            FROM matches
+            WHERE league_id = :league_id
+              AND sport = 'football'
+              AND status = 'FT'
+              AND score_home IS NOT NULL
+              AND score_away IS NOT NULL
+              AND mst_utc < :before_ts
+            ORDER BY mst_utc DESC
+            LIMIT 100
+        ) m
+    """)
+    result = await session.execute(
+        query,
+        {"league_id": league_id, "before_ts": before_mst_utc},
+    )
+    row = result.mappings().first()
+    if row is None or int(row["match_count"] or 0) == 0:
+        return None
+    return {"avg_goals": round(float(row["avg_goals"]), 3)}
+
+
+async def _load_referee_profile(
+    session: AsyncSession,
+    referee_name: str,
+    before_mst_utc: int,
+) -> dict[str, float] | None:
+    if not referee_name:
+        return None
+
+    query = text("""
+        SELECT
+            COALESCE(AVG(CASE WHEN score_home > score_away THEN 1.0 ELSE 0.0 END), 0.46) - 0.46 AS home_bias,
+            COALESCE(AVG(score_home + score_away), 2.6) AS avg_goals,
+            COUNT(*) AS match_count
+        FROM (
+            SELECT m.score_home, m.score_away
+            FROM match_officials mo
+            JOIN matches m ON m.id = mo.match_id
+            WHERE mo.name = :referee_name
+              AND mo.role_id = 1
+              AND m.sport = 'football'
+              AND m.status = 'FT'
+              AND m.score_home IS NOT NULL
+              AND m.score_away IS NOT NULL
+              AND m.mst_utc < :before_ts
+            ORDER BY m.mst_utc DESC
+            LIMIT 30
+        ) ref_matches
+    """)
+    result = await session.execute(
+        query,
+        {"referee_name": referee_name, "before_ts": before_mst_utc},
+    )
+    row = result.mappings().first()
+    if row is None or int(row["match_count"] or 0) == 0:
+        return None
+    return {
+        "home_bias": round(float(row["home_bias"]), 4),
+        "avg_goals": round(float(row["avg_goals"]), 3),
+    }
+
+
+async def _load_team_squad_profile(
+    session: AsyncSession,
+    team_id: str,
+    before_mst_utc: int,
+) -> dict[str, float] | None:
+    if not team_id:
+        return None
+
+    query = text("""
+        WITH recent_matches AS (
+            SELECT m.id, m.mst_utc
+            FROM matches m
+            WHERE (m.home_team_id = :team_id OR m.away_team_id = :team_id)
+              AND m.sport = 'football'
+              AND m.status = 'FT'
+              AND m.mst_utc < :before_ts
+            ORDER BY m.mst_utc DESC
+            LIMIT 8
+        ),
+        player_base AS (
+            SELECT
+                mpp.player_id,
+                COUNT(*)::float AS appearances,
+                COUNT(*) FILTER (WHERE mpp.is_starting = true)::float AS starts
+            FROM match_player_participation mpp
+            JOIN recent_matches rm ON rm.id = mpp.match_id
+            WHERE mpp.team_id = :team_id
+            GROUP BY mpp.player_id
+        ),
+        player_goals AS (
+            SELECT
+                mpe.player_id,
+                COUNT(*) FILTER (
+                    WHERE mpe.event_type = 'goal'
+                      AND COALESCE(mpe.event_subtype, '') NOT ILIKE '%penaltı kaçırma%'
+                )::float AS goals,
+                0.0::float AS assists
+            FROM match_player_events mpe
+            JOIN recent_matches rm ON rm.id = mpe.match_id
+            WHERE mpe.team_id = :team_id
+            GROUP BY mpe.player_id
+            UNION ALL
+            SELECT
+                mpe.assist_player_id AS player_id,
+                0.0::float AS goals,
+                COUNT(*) FILTER (
+                    WHERE mpe.event_type = 'goal'
+                      AND mpe.assist_player_id IS NOT NULL
+                )::float AS assists
+            FROM match_player_events mpe
+            JOIN recent_matches rm ON rm.id = mpe.match_id
+            WHERE mpe.team_id = :team_id
+              AND mpe.assist_player_id IS NOT NULL
+            GROUP BY mpe.assist_player_id
+        ),
+        player_events AS (
+            SELECT
+                player_id,
+                SUM(goals) AS goals,
+                SUM(assists) AS assists
+            FROM player_goals
+            GROUP BY player_id
+        ),
+        player_scores AS (
+            SELECT
+                pb.player_id,
+                (pb.starts * 1.5)
+                + ((pb.appearances - pb.starts) * 0.5)
+                + (COALESCE(pe.goals, 0.0) * 2.5)
+                + (COALESCE(pe.assists, 0.0) * 1.5) AS score
+            FROM player_base pb
+            LEFT JOIN player_events pe ON pe.player_id = pb.player_id
+        )
+        SELECT
+            COALESCE(AVG(top_players.score), 0.0) AS avg_top_score,
+            COALESCE(COUNT(*) FILTER (WHERE top_players.score >= 6.0), 0) AS key_players,
+            COALESCE((SELECT COUNT(*) FROM recent_matches), 0) AS match_count
+        FROM (
+            SELECT score
+            FROM player_scores
+            ORDER BY score DESC
+            LIMIT 11
+        ) top_players
+    """)
+    result = await session.execute(
+        query,
+        {"team_id": team_id, "before_ts": before_mst_utc},
+    )
+    row = result.mappings().first()
+    if row is None or int(row["match_count"] or 0) == 0:
+        return None
+
+    avg_top_score = float(row["avg_top_score"] or 0.0)
+    return {
+        "squad_strength": round(min(max(avg_top_score / 10.0, 0.0), 1.0), 4),
+        "key_players": float(row["key_players"] or 0),
+    }
+
+
+def _safe_json(value: Any) -> dict[str, Any] | None:
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+        except (TypeError, json.JSONDecodeError):
+            return None
+        return parsed if isinstance(parsed, dict) else None
+    return None
+
+
+def _safe_list(value: Any) -> list[Any]:
+    if isinstance(value, list):
+        return value
+    return []
+
+
+def _extract_lineup_context(match_row: dict[str, Any]) -> dict[str, float | bool]:
+    lineups = _safe_json(match_row.get("lineups"))
+    sidelined = _safe_json(match_row.get("sidelined"))
+
+    home_xi_count = 0
+    away_xi_count = 0
+    home_sidelined_count = 0
+    away_sidelined_count = 0
+
+    if lineups:
+        home_xi_count = len(_safe_list(lineups.get("home", {}).get("xi")))
+        away_xi_count = len(_safe_list(lineups.get("away", {}).get("xi")))
+
+    if sidelined:
+        home_team = sidelined.get("homeTeam", {})
+        away_team = sidelined.get("awayTeam", {})
+        home_sidelined_count = max(
+            int(home_team.get("totalSidelined") or 0),
+            len(_safe_list(home_team.get("players"))),
+        )
+        away_sidelined_count = max(
+            int(away_team.get("totalSidelined") or 0),
+            len(_safe_list(away_team.get("players"))),
+        )
+
+    has_real_lineup_data = any(
+        value > 0
+        for value in (
+            home_xi_count,
+            away_xi_count,
+            home_sidelined_count,
+            away_sidelined_count,
+        )
+    )
+
+    home_availability = _compute_availability(home_xi_count, home_sidelined_count)
+    away_availability = _compute_availability(away_xi_count, away_sidelined_count)
+
+    return {
+        "home_availability": home_availability,
+        "away_availability": away_availability,
+        "has_real_lineup_data": has_real_lineup_data,
+    }
+
+
+def _compute_availability(xi_count: int, sidelined_count: int) -> float:
+    xi_ratio = min(max(xi_count / 11.0, 0.0), 1.0) if xi_count > 0 else 1.0
+    sidelined_penalty = min(max(sidelined_count / 11.0, 0.0), 1.0) * 0.35
+    return round(min(max(xi_ratio - sidelined_penalty, 0.0), 1.0), 4)
+
+
+def _safe_odd(val: Any) -> float:
+    """Parse an odds value that might be str, float, int, or None."""
+    if val is None:
+        return 0.0
+    try:
+        parsed = float(val)
+        return parsed if parsed > 1.0 else 0.0
+    except (ValueError, TypeError):
+        return 0.0
+
+
+def _implied_prob(decimal_odd: float) -> float:
+    """Convert decimal odds to implied probability, clamped [0, 1]."""
+    if decimal_odd <= 1.0:
+        return 0.0
+    return min(1.0, 1.0 / decimal_odd)
+
+
+async def _extract_odds(
+    session: AsyncSession,
+    match_id: str,
+    feats: MatchFeatures,
+) -> bool:
+    """Extract odds from live JSON first, then relational tables."""
+    found = False
+
+    odds_json = await _load_live_odds_json(session, match_id)
+    if odds_json:
+        found = _parse_odds_json(odds_json, feats)
+
+    if not found:
+        found = await _load_relational_odds(session, match_id, feats)
+
+    if found:
+        feats.implied_prob_home = round(_implied_prob(feats.odds_home), 4)
+        feats.implied_prob_draw = round(_implied_prob(feats.odds_draw), 4)
+        feats.implied_prob_away = round(_implied_prob(feats.odds_away), 4)
+        feats.implied_prob_over25 = round(_implied_prob(feats.odds_over25), 4)
+        feats.implied_prob_under25 = round(_implied_prob(feats.odds_under25), 4)
+        feats.implied_prob_btts_yes = round(_implied_prob(feats.odds_btts_yes), 4)
+        feats.implied_prob_btts_no = round(_implied_prob(feats.odds_btts_no), 4)
+
+    return found
+
+
+async def _load_live_odds_json(
+    session: AsyncSession, match_id: str,
+) -> dict[str, Any] | None:
+    query = text("SELECT odds FROM live_matches WHERE id = :mid AND odds IS NOT NULL")
+    result = await session.execute(query, {"mid": match_id})
+    row = result.scalar_one_or_none()
+    if row is None:
+        return None
+    if isinstance(row, str):
+        try:
+            parsed = json.loads(row)
+        except (json.JSONDecodeError, TypeError):
+            return None
+        return parsed if isinstance(parsed, (dict, list)) else None
+    if isinstance(row, (dict, list)):
+        return row
+    return None
+
+
+def _parse_odds_json(odds_blob: dict[str, Any] | list[Any], feats: MatchFeatures) -> bool:
+    """Parse the Mackolik-style odds JSON structure."""
+    found_any = False
+    categories: list[dict[str, Any]] = []
+    if isinstance(odds_blob, list):
+        categories = [item for item in odds_blob if isinstance(item, dict)]
+    elif isinstance(odds_blob, dict):
+        raw_categories = odds_blob.get("categories", odds_blob.get("odds", []))
+        if isinstance(raw_categories, dict):
+            categories = [item for item in raw_categories.values() if isinstance(item, dict)]
+        elif isinstance(raw_categories, list):
+            categories = [item for item in raw_categories if isinstance(item, dict)]
+
+    for cat in categories:
+        cat_name = (cat.get("name") or cat.get("cn") or "").strip().lower()
+        selections = cat.get("selections") or cat.get("s") or []
+
+        if cat_name in ("mac sonucu", "match result", "1x2", "maç sonucu"):
+            sels = _selections_to_map(selections)
+            feats.odds_home = _safe_odd(sels.get("1")) or feats.odds_home
+            feats.odds_draw = _safe_odd(sels.get("x")) or feats.odds_draw
+            feats.odds_away = _safe_odd(sels.get("2")) or feats.odds_away
+            found_any = True
+
+        elif cat_name in ("2,5 alt/ust", "over/under 2.5", "2.5 alt/ust", "2,5 alt/üst", "2.5 alt/üst"):
+            sels = _selections_to_map(selections)
+            feats.odds_over25 = _safe_odd(sels.get("ust") or sels.get("over") or sels.get("üst")) or feats.odds_over25
+            feats.odds_under25 = _safe_odd(sels.get("alt") or sels.get("under")) or feats.odds_under25
+            found_any = True
+
+        elif cat_name in ("karsilikli gol", "both teams to score", "btts", "karşılıklı gol"):
+            sels = _selections_to_map(selections)
+            feats.odds_btts_yes = _safe_odd(sels.get("var") or sels.get("yes")) or feats.odds_btts_yes
+            feats.odds_btts_no = _safe_odd(sels.get("yok") or sels.get("no")) or feats.odds_btts_no
+            found_any = True
+
+    return found_any
+
+
+def _selections_to_map(selections: list[Any] | dict[str, Any]) -> dict[str, Any]:
+    """Normalize varied selection structures into {name_lower: odd_value}."""
+    result: dict[str, Any] = {}
+    if isinstance(selections, dict):
+        for key, value in selections.items():
+            result[str(key).strip().lower()] = value
+    elif isinstance(selections, list):
+        for sel in selections:
+            if isinstance(sel, dict):
+                name = (sel.get("name") or sel.get("n") or "").strip().lower()
+                value = sel.get("odd_value") or sel.get("ov") or sel.get("v")
+                if name:
+                    result[name] = value
+    return result
+
+
+async def _load_relational_odds(
+    session: AsyncSession, match_id: str, feats: MatchFeatures,
+) -> bool:
+    """Fallback: load odds from odd_categories + odd_selections."""
+    query = text("""
+        SELECT oc.name AS cat_name, os.name AS sel_name, os.odd_value
+        FROM odd_categories oc
+        JOIN odd_selections os ON os.odd_category_db_id = oc.db_id
+        WHERE oc.match_id = :match_id
+          AND oc.name IN ('Maç Sonucu', '2,5 Alt/Üst', 'Karşılıklı Gol')
+    """)
+    result = await session.execute(query, {"match_id": match_id})
+    rows = result.mappings().all()
+    if not rows:
+        return False
+
+    for row in rows:
+        cat = (row["cat_name"] or "").strip()
+        sel = (row["sel_name"] or "").strip().lower()
+        value = _safe_odd(row["odd_value"])
+        if value <= 1.0:
+            continue
+
+        if cat == "Maç Sonucu":
+            if sel == "1":
+                feats.odds_home = value
+            elif sel == "x":
+                feats.odds_draw = value
+            elif sel == "2":
+                feats.odds_away = value
+        elif cat == "2,5 Alt/Üst":
+            if sel in ("üst", "ust", "over"):
+                feats.odds_over25 = value
+            elif sel in ("alt", "under"):
+                feats.odds_under25 = value
+        elif cat == "Karşılıklı Gol":
+            if sel in ("var", "yes"):
+                feats.odds_btts_yes = value
+            elif sel in ("yok", "no"):
+                feats.odds_btts_no = value
+
+    return True
@@ -0,0 +1,256 @@
+"""
+Feature Adapter for XGBoost Inference
+=====================================
+Bridges the gap between V20 Engine outputs (CalculationContext) and XGBoost Models.
+Constructs the exact 44-feature vector used in training.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import psycopg2
+from psycopg2.extensions import connection as PgConnection
+import pandas as pd
+import numpy as np
+
+from data.db import get_clean_dsn
+
+# Feature definitions (Must match train_xgboost_markets.py)
+# NOTE: 68 features - matching the trained XGBoost models
+FEATURES = [
+    # ELO
+    "home_overall_elo", "away_overall_elo", "elo_diff",
+    "home_home_elo", "away_away_elo", "form_elo_diff",
+    
+    # Form
+    "home_goals_avg", "home_conceded_avg",
+    "away_goals_avg", "away_conceded_avg",
+    "home_clean_sheet_rate", "away_clean_sheet_rate",
+    "home_scoring_rate", "away_scoring_rate",
+    "home_winning_streak", "away_winning_streak",
+    
+    # H2H
+    "h2h_home_win_rate", "h2h_draw_rate",
+    "h2h_avg_goals", "h2h_btts_rate", "h2h_over25_rate",
+    
+    # Stats
+    "home_avg_possession", "away_avg_possession",
+    "home_avg_shots_on_target", "away_avg_shots_on_target",
+    "home_shot_conversion", "away_shot_conversion",
+    
+    # Odds (Implicit market wisdom)
+    "odds_ms_h", "odds_ms_d", "odds_ms_a",
+    "implied_home", "implied_draw", "implied_away",
+    
+    "odds_ht_ms_h", "odds_ht_ms_d", "odds_ht_ms_a",
+    
+    "odds_ou05_o", "odds_ou05_u",
+    "odds_ou15_o", "odds_ou15_u",
+    "odds_ou25_o", "odds_ou25_u",
+    "odds_ou35_o", "odds_ou35_u",
+    
+    "odds_ht_ou05_o", "odds_ht_ou05_u",
+    "odds_ht_ou15_o", "odds_ht_ou15_u",
+    
+    "odds_btts_y", "odds_btts_n",
+    
+    # League/Context
+    "league_avg_goals", "league_zero_goal_rate",
+    "home_xga", "away_xga",
+    
+    # Upset features
+    "upset_atmosphere", "upset_motivation", "upset_fatigue", "upset_potential",
+    
+    # Referee features
+    "referee_home_bias", "referee_avg_goals", "referee_cards_total",
+    "referee_avg_yellow", "referee_experience",
+    
+    # Momentum features
+    "home_momentum_score", "away_momentum_score", "momentum_diff",
+]
+
+class FeatureAdapter:
+    """
+    Adapter to convert V20 context into XGBoost-compatible features.
+    """
+    
+    def __init__(self) -> None:
+        self.conn: PgConnection | None = None
+        self._connect_db()
+        self.league_stats_cache: dict[str, dict[str, float]] = {}
+
+    def _connect_db(self) -> None:
+        try:
+            # FeatureAdapter uses DB only for optional league stats enrichment.
+            # Keep startup non-blocking when DB/tunnel is unavailable.
+            if not os.getenv("DATABASE_URL", "").strip():
+                return
+            self.conn = psycopg2.connect(get_clean_dsn())
+        except Exception as e:
+            print(f"⚠️ FeatureAdapter DB connection failed: {e}")
+            
+    def get_features(self, ctx: Any) -> pd.DataFrame:
+        """
+        Construct feature vector from CalculationContext.
+        Returns a DataFrame with 1 row and correct columns.
+        """
+        raw = ctx.team_pred.raw_features
+        odds = ctx.odds_data or {}
+        upset_features = getattr(ctx, "upset_features", {}) or {}
+        momentum_features = getattr(ctx, "momentum_features", {}) or {}
+        referee_features = getattr(ctx, "referee_features", {}) or {}
+        
+        # 1. Odds Features
+        ms_h = float(odds.get("ms_h") or 0)
+        ms_d = float(odds.get("ms_d") or 0)
+        ms_a = float(odds.get("ms_a") or 0)
+        
+        implied_home, implied_draw, implied_away = 0.33, 0.33, 0.33
+        if ms_h > 0 and ms_d > 0 and ms_a > 0:
+            raw_sum = 1/ms_h + 1/ms_d + 1/ms_a
+            implied_home = (1/ms_h) / raw_sum
+            implied_draw = (1/ms_d) / raw_sum
+            implied_away = (1/ms_a) / raw_sum
+            
+        # 2. League Features
+        # Using ctx.league_id if available, or just defaults
+        league_stats = self._get_league_stats(ctx.league_id)
+        
+        # 3. Assemble Dictionary
+        row = {
+            # ELO (Explicit float casting)
+            "home_overall_elo": float(raw.get("home_overall_elo") or 1500),
+            "away_overall_elo": float(raw.get("away_overall_elo") or 1500),
+            "elo_diff": float(raw.get("elo_diff") or 0),
+            "home_home_elo": float(raw.get("home_home_elo") or 1500),
+            "away_away_elo": float(raw.get("away_away_elo") or 1500),
+            "form_elo_diff": float(raw.get("form_elo_diff") or 0),
+
+            # Form (Explicit float casting)
+            "home_goals_avg": float(raw.get("home_goals_avg") or 1.3),
+            "home_conceded_avg": float(raw.get("home_conceded_avg") or 1.2),
+            "away_goals_avg": float(raw.get("away_goals_avg") or 1.2),
+            "away_conceded_avg": float(raw.get("away_conceded_avg") or 1.4),
+            "home_clean_sheet_rate": float(raw.get("home_clean_sheet_rate") or 0.2),
+            "away_clean_sheet_rate": float(raw.get("away_clean_sheet_rate") or 0.2),
+            "home_scoring_rate": float(raw.get("home_scoring_rate") or 0.8),
+            "away_scoring_rate": float(raw.get("away_scoring_rate") or 0.8),
+            "home_winning_streak": float(raw.get("home_winning_streak") or 0),
+            "away_winning_streak": float(raw.get("away_winning_streak") or 0),
+
+            # H2H (Explicit float casting)
+            "h2h_home_win_rate": float(raw.get("h2h_home_win_rate") or 0.33),
+            "h2h_draw_rate": float(raw.get("h2h_draw_rate") or 0.33),
+            "h2h_avg_goals": float(raw.get("h2h_avg_goals") or 2.5),
+            "h2h_btts_rate": float(raw.get("h2h_btts_rate") or 0.5),
+            "h2h_over25_rate": float(raw.get("h2h_over25_rate") or 0.5),
+            
+            # Stats (Explicit float casting to avoid XGBoost 'object' error)
+            "home_avg_possession": float(raw.get("home_avg_possession") or 0.5),
+            "away_avg_possession": float(raw.get("away_avg_possession") or 0.5),
+            "home_avg_shots_on_target": float(raw.get("home_avg_shots_on_target") or 4.0),
+            "away_avg_shots_on_target": float(raw.get("away_avg_shots_on_target") or 3.5),
+            "home_shot_conversion": float(raw.get("home_shot_conversion") or 0.1),
+            "away_shot_conversion": float(raw.get("away_shot_conversion") or 0.1),
+            
+            # Odds
+            "odds_ms_h": ms_h,
+            "odds_ms_d": ms_d,
+            "odds_ms_a": ms_a,
+            "implied_home": implied_home,
+            "implied_draw": implied_draw,
+            "implied_away": implied_away,
+            
+            "odds_ht_ms_h": float(odds.get("ht_ms_h") or 0.0),
+            "odds_ht_ms_d": float(odds.get("ht_ms_d") or 0.0),
+            "odds_ht_ms_a": float(odds.get("ht_ms_a") or 0.0),
+            
+            "odds_ou05_o": float(odds.get("ou05_o") or 0.0),
+            "odds_ou05_u": float(odds.get("ou05_u") or 0.0),
+            "odds_ou15_o": float(odds.get("ou15_o") or 0.0),
+            "odds_ou15_u": float(odds.get("ou15_u") or 0.0),
+            "odds_ou25_o": float(odds.get("ou25_o") or 0.0),
+            "odds_ou25_u": float(odds.get("ou25_u") or 0.0),
+            "odds_ou35_o": float(odds.get("ou35_o") or 0.0),
+            "odds_ou35_u": float(odds.get("ou35_u") or 0.0),
+            
+            "odds_ht_ou05_o": float(odds.get("ht_ou05_o") or 0.0),
+            "odds_ht_ou05_u": float(odds.get("ht_ou05_u") or 0.0),
+            "odds_ht_ou15_o": float(odds.get("ht_ou15_o") or 0.0),
+            "odds_ht_ou15_u": float(odds.get("ht_ou15_u") or 0.0),
+            
+            "odds_btts_y": float(odds.get("btts_y") or 0.0),
+            "odds_btts_n": float(odds.get("btts_n") or 0.0),
+            
+            # League/Def
+            "league_avg_goals": float(league_stats.get("avg_goals") or 2.7),
+            "league_zero_goal_rate": float(league_stats.get("zero_rate") or 0.07),
+            "home_xga": float(raw.get("home_xga") or 1.2),
+            "away_xga": float(raw.get("away_xga") or 1.4),
+
+            # Upset features (default values - computed separately in upset_engine_v2)
+            "upset_atmosphere": float(raw.get("upset_atmosphere") or 0.0),
+            "upset_motivation": float(raw.get("upset_motivation") or 0.0),
+            "upset_fatigue": float(raw.get("upset_fatigue") or 0.0),
+            "upset_potential": float(raw.get("upset_potential") or 0.0),
+
+            # Referee features (default values)
+            "referee_home_bias": float(raw.get("referee_home_bias") or 0.0),
+            "referee_avg_goals": float(raw.get("referee_avg_goals") or 2.5),
+            "referee_cards_total": float(raw.get("referee_cards_total") or 4.0),
+            "referee_avg_yellow": float(raw.get("referee_avg_yellow") or 3.0),
+            "referee_experience": float(raw.get("referee_experience") or 0),
+
+            # Momentum features (default values)
+            "home_momentum_score": float(raw.get("home_momentum_score") or 0.0),
+            "away_momentum_score": float(raw.get("away_momentum_score") or 0.0),
+            "momentum_diff": float(raw.get("momentum_diff") or 0.0),
+        }
+        
+        # Return as DataFrame (cols sorted by FEATURES list to ensure alignment)
+        df = pd.DataFrame([row], columns=FEATURES)
+        return df
+
+    def _get_league_stats(self, league_id: str | None) -> dict[str, float]:
+        """Get cached league stats or default."""
+        if not league_id:
+            return {"avg_goals": 2.7, "zero_rate": 0.07}
+            
+        if league_id in self.league_stats_cache:
+            return self.league_stats_cache[league_id]
+            
+        if self.conn:
+            try:
+                with self.conn.cursor() as cur:
+                    cur.execute("""
+                        SELECT AVG(score_home + score_away),
+                               AVG(CASE WHEN score_home=0 AND score_away=0 THEN 1.0 ELSE 0.0 END)
+                        FROM matches 
+                        WHERE league_id = %s AND status = 'FT' 
+                          AND mst_utc > EXTRACT(EPOCH FROM NOW() - INTERVAL '1 year')
+                    """, (league_id,))
+                    res = cur.fetchone()
+                    if res and res[0]:
+                        stats = {
+                            "avg_goals": float(res[0]),
+                            "zero_rate": float(res[1])
+                        }
+                        self.league_stats_cache[league_id] = stats
+                        return stats
+            except Exception:
+                pass
+                
+        # Default fallback
+        return {"avg_goals": 2.7, "zero_rate": 0.07}
+
+# Singleton
+_adapter: FeatureAdapter | None = None
+
+
+def get_feature_adapter() -> FeatureAdapter:
+    global _adapter
+    if _adapter is None:
+        _adapter = FeatureAdapter()
+    return _adapter
@@ -0,0 +1,316 @@
+"""
+Head-to-Head (H2H) Feature Engine
+Takımların birbirine karşı geçmiş performansını analiz eder.
+"""
+
+import os
+import psycopg2
+from typing import Dict, Optional, Tuple
+from dataclasses import dataclass
+from functools import lru_cache
+
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from data.db import get_clean_dsn
+
+
+@dataclass
+class H2HProfile:
+    """Head-to-Head analiz sonucu"""
+    total_matches: int
+    home_wins: int
+    draws: int
+    away_wins: int
+    home_goals_total: int
+    away_goals_total: int
+    btts_count: int  # Both teams to score
+    over25_count: int
+    
+    @property
+    def home_win_rate(self) -> float:
+        return self.home_wins / self.total_matches if self.total_matches > 0 else 0.33
+    
+    @property
+    def draw_rate(self) -> float:
+        return self.draws / self.total_matches if self.total_matches > 0 else 0.33
+    
+    @property
+    def away_win_rate(self) -> float:
+        return self.away_wins / self.total_matches if self.total_matches > 0 else 0.33
+    
+    @property
+    def avg_total_goals(self) -> float:
+        return (self.home_goals_total + self.away_goals_total) / self.total_matches if self.total_matches > 0 else 2.5
+    
+    @property
+    def btts_rate(self) -> float:
+        return self.btts_count / self.total_matches if self.total_matches > 0 else 0.5
+    
+    @property
+    def over25_rate(self) -> float:
+        return self.over25_count / self.total_matches if self.total_matches > 0 else 0.5
+    
+    @property
+    def home_dominance(self) -> float:
+        """Ev sahibinin üstünlük skoru (-1 ile 1 arası)"""
+        if self.total_matches == 0:
+            return 0
+        return (self.home_wins - self.away_wins) / self.total_matches
+    
+    def to_features(self) -> Dict[str, float]:
+        """Feature dictionary döndür"""
+        return {
+            'h2h_total_matches': self.total_matches,
+            'h2h_home_win_rate': self.home_win_rate,
+            'h2h_draw_rate': self.draw_rate,
+            'h2h_away_win_rate': self.away_win_rate,
+            'h2h_avg_goals': self.avg_total_goals,
+            'h2h_btts_rate': self.btts_rate,
+            'h2h_over25_rate': self.over25_rate,
+            'h2h_home_dominance': self.home_dominance,
+        }
+
+
+class H2HFeatureEngine:
+    """
+    Head-to-Head Feature Engine
+    
+    İki takım arasındaki geçmiş karşılaşmaları analiz eder.
+    """
+    
+    def __init__(self):
+        self.conn = None
+        self._cache: Dict[Tuple[str, str], H2HProfile] = {}
+    
+    def get_conn(self):
+        if self.conn is None or self.conn.closed:
+            self.conn = psycopg2.connect(get_clean_dsn())
+        return self.conn
+    
+    def get_h2h_profile(self, home_team_id: str, away_team_id: str, 
+                        before_date: Optional[int] = None, 
+                        limit: int = 20) -> H2HProfile:
+        """
+        İki takım arasındaki geçmiş karşılaşmaları analiz et.
+        
+        Args:
+            home_team_id: Ev sahibi takım ID
+            away_team_id: Deplasman takım ID
+            before_date: Bu tarihten önceki maçlar (mst_utc, milliseconds)
+            limit: Kaç maç geriye bakılacak
+            
+        Returns:
+            H2HProfile: Head-to-head analiz sonucu
+        """
+        cache_key = (home_team_id, away_team_id)
+        
+        # Cache kontrolü (before_date yoksa)
+        if before_date is None and cache_key in self._cache:
+            return self._cache[cache_key]
+        
+        conn = self.get_conn()
+        cur = conn.cursor()
+        
+        # Her iki yöndeki karşılaşmaları al
+        # (A evde B deplasman + B evde A deplasman)
+        query = """
+            SELECT 
+                home_team_id, away_team_id,
+                score_home, score_away
+            FROM matches
+            WHERE (
+                (home_team_id = %s AND away_team_id = %s)
+                OR 
+                (home_team_id = %s AND away_team_id = %s)
+            )
+            AND score_home IS NOT NULL
+            AND score_away IS NOT NULL
+        """
+        
+        params = [home_team_id, away_team_id, away_team_id, home_team_id]
+        
+        if before_date:
+            query += " AND mst_utc < %s"
+            params.append(before_date)
+        
+        query += " ORDER BY mst_utc DESC LIMIT %s"
+        params.append(limit)
+        
+        cur.execute(query, params)
+        matches = cur.fetchall()
+        
+        if not matches:
+            return H2HProfile(
+                total_matches=0, home_wins=0, draws=0, away_wins=0,
+                home_goals_total=0, away_goals_total=0,
+                btts_count=0, over25_count=0
+            )
+        
+        # İstatistikleri hesapla
+        home_wins = 0
+        draws = 0
+        away_wins = 0
+        home_goals = 0
+        away_goals = 0
+        btts = 0
+        over25 = 0
+        
+        for match in matches:
+            m_home_id, m_away_id, score_h, score_a = match
+            
+            # Perspektifi normalize et (istenen takım açısından)
+            if m_home_id == home_team_id:
+                # Normal sıralama
+                h_score, a_score = score_h, score_a
+            else:
+                # Ters sıralama (rakip evde oynamış)
+                h_score, a_score = score_a, score_h
+            
+            # Sonuç
+            if h_score > a_score:
+                home_wins += 1
+            elif h_score < a_score:
+                away_wins += 1
+            else:
+                draws += 1
+            
+            # Goller
+            home_goals += h_score
+            away_goals += a_score
+            
+            # BTTS
+            if h_score > 0 and a_score > 0:
+                btts += 1
+            
+            # Over 2.5
+            if h_score + a_score > 2.5:
+                over25 += 1
+        
+        profile = H2HProfile(
+            total_matches=len(matches),
+            home_wins=home_wins,
+            draws=draws,
+            away_wins=away_wins,
+            home_goals_total=home_goals,
+            away_goals_total=away_goals,
+            btts_count=btts,
+            over25_count=over25
+        )
+        
+        # Cache'e kaydet
+        if before_date is None:
+            self._cache[cache_key] = profile
+        
+        return profile
+    
+    def get_features(self, home_team_id: str, away_team_id: str, 
+                     before_date: Optional[int] = None) -> Dict[str, float]:
+        """Feature dictionary döndür"""
+        profile = self.get_h2h_profile(home_team_id, away_team_id, before_date)
+        return profile.to_features()
+    
+    def get_momentum(self, home_team_id: str, away_team_id: str,
+                     before_date: Optional[int] = None) -> Dict[str, float]:
+        """
+        Son karşılaşmalardaki momentum/trend analizi.
+        Son 5 maçtaki trend'e bakar.
+        """
+        profile = self.get_h2h_profile(home_team_id, away_team_id, before_date, limit=5)
+        
+        # Streak hesapla (ardışık sonuçlar)
+        conn = self.get_conn()
+        cur = conn.cursor()
+        
+        query = """
+            SELECT home_team_id, score_home, score_away
+            FROM matches
+            WHERE (
+                (home_team_id = %s AND away_team_id = %s)
+                OR 
+                (home_team_id = %s AND away_team_id = %s)
+            )
+            AND score_home IS NOT NULL
+        """
+        params = [home_team_id, away_team_id, away_team_id, home_team_id]
+        if before_date:
+            query += " AND mst_utc < %s"
+            params.append(before_date)
+        query += " ORDER BY mst_utc DESC LIMIT 5"
+        
+        cur.execute(query, params)
+        recent = cur.fetchall()
+        
+        streak = 0
+        streak_type = None  # 'home', 'away', 'draw'
+        
+        for match in recent:
+            m_home_id, score_h, score_a = match
+            
+            # Perspektifi normalize et
+            if m_home_id == home_team_id:
+                result = 'home' if score_h > score_a else ('away' if score_h < score_a else 'draw')
+            else:
+                result = 'away' if score_h > score_a else ('home' if score_h < score_a else 'draw')
+            
+            if streak_type is None:
+                streak_type = result
+                streak = 1
+            elif result == streak_type:
+                streak += 1
+            else:
+                break
+        
+        return {
+            'h2h_recent_home_dominance': profile.home_dominance,
+            'h2h_streak_length': streak,
+            'h2h_streak_home': 1 if streak_type == 'home' else 0,
+            'h2h_streak_away': 1 if streak_type == 'away' else 0,
+            'h2h_streak_draw': 1 if streak_type == 'draw' else 0,
+        }
+
+
+# Singleton
+_engine = None
+
+def get_h2h_engine() -> H2HFeatureEngine:
+    global _engine
+    if _engine is None:
+        _engine = H2HFeatureEngine()
+    return _engine
+
+
+if __name__ == "__main__":
+    # Test
+    engine = get_h2h_engine()
+    
+    # Örnek: Fenerbahçe vs Galatasaray (ID'leri bulunmalı)
+    # Test için veritabanından bir karşılaşma çekelim
+    conn = engine.get_conn()
+    cur = conn.cursor()
+    cur.execute("""
+        SELECT home_team_id, away_team_id, match_name
+        FROM matches
+        WHERE score_home IS NOT NULL
+        LIMIT 1
+    """)
+    result = cur.fetchone()
+    
+    if result:
+        home_id, away_id, name = result
+        print(f"\n🧪 Test: {name}")
+        print(f"   Home ID: {home_id}")
+        print(f"   Away ID: {away_id}")
+        
+        profile = engine.get_h2h_profile(home_id, away_id)
+        print(f"\n📊 H2H Profil:")
+        print(f"   Toplam Maç: {profile.total_matches}")
+        print(f"   Ev Sahibi Kazanma: {profile.home_win_rate:.1%}")
+        print(f"   Beraberlik: {profile.draw_rate:.1%}")
+        print(f"   Deplasman Kazanma: {profile.away_win_rate:.1%}")
+        print(f"   Ortalama Gol: {profile.avg_total_goals:.2f}")
+        print(f"   BTTS Oranı: {profile.btts_rate:.1%}")
+        print(f"   Üst 2.5 Oranı: {profile.over25_rate:.1%}")
+        print(f"   Ev Dominance: {profile.home_dominance:+.2f}")
+        
+        features = engine.get_features(home_id, away_id)
+        print(f"\n🔧 Features: {features}")
@@ -0,0 +1,343 @@
+"""
+HT/FT Tendency Feature Engine
+================================
+Produces team-level HT/FT tendency features for match prediction.
+
+Computes ~15 features per match based on historical data:
+  - 1st half scoring/conceding rates
+  - Comeback rates
+  - Half-specific goal distribution
+  - League-level HT/FT profiles
+
+All features are computed from the `matches` table using only data
+BEFORE the match date (no future leakage).
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from typing import Dict, Optional, Tuple
+from dataclasses import dataclass, field
+from data.db import get_clean_dsn
+import psycopg2
+
+
+@dataclass
+class TeamHtftProfile:
+    """HT/FT tendency profile for a single team."""
+    matches: int = 0
+    ht_scored: int = 0        # Matches where team scored in 1st half
+    ht_conceded: int = 0      # Matches where team conceded in 1st half
+    ht_leading: int = 0       # Matches where team led at HT
+    ht_trailing: int = 0      # Matches where team trailed at HT
+    comeback_wins: int = 0    # Trailing at HT -> Won
+    goals_1h: int = 0
+    goals_2h: int = 0
+    conceded_1h: int = 0
+    conceded_2h: int = 0
+
+    @property
+    def ht_scoring_rate(self):
+        return self.ht_scored / self.matches if self.matches > 0 else 0.5
+
+    @property
+    def ht_concede_rate(self):
+        return self.ht_conceded / self.matches if self.matches > 0 else 0.5
+
+    @property
+    def ht_win_rate(self):
+        return self.ht_leading / self.matches if self.matches > 0 else 0.33
+
+    @property
+    def comeback_rate(self):
+        return self.comeback_wins / self.ht_trailing if self.ht_trailing > 0 else 0.0
+
+    @property
+    def first_half_goal_pct(self):
+        total = self.goals_1h + self.goals_2h
+        return self.goals_1h / total if total > 0 else 0.5
+
+    @property
+    def second_half_surge(self):
+        """Ratio of 2H goals vs 1H goals. >1 means more dangerous in 2nd half."""
+        return self.goals_2h / self.goals_1h if self.goals_1h > 0 else 1.0
+
+
+@dataclass
+class LeagueHtftProfile:
+    """League-level HT/FT statistics."""
+    matches: int = 0
+    ht_goals_total: int = 0
+    ft_goals_total: int = 0
+    reversals: int = 0
+    htft_counts: Dict[str, int] = field(default_factory=dict)
+
+    @property
+    def avg_ht_goals(self):
+        return self.ht_goals_total / self.matches if self.matches > 0 else 1.0
+
+    @property
+    def avg_2h_goals(self):
+        ft = self.ft_goals_total / self.matches if self.matches > 0 else 2.5
+        return ft - self.avg_ht_goals
+
+    @property
+    def reversal_rate(self):
+        return self.reversals / self.matches if self.matches > 0 else 0.05
+
+    @property
+    def first_half_pct(self):
+        return self.ht_goals_total / self.ft_goals_total if self.ft_goals_total > 0 else 0.44
+
+
+class HtftTendencyEngine:
+    """
+    Computes HT/FT tendency features for a given match.
+
+    Uses historical data from `matches` table, filtering by date to
+    avoid future leakage.
+
+    Features are based on team-level and league-level tendencies, which
+    are DIFFERENT from the existing model features (ELO, form, H2H score).
+    """
+
+    def __init__(self):
+        self.conn = None
+        self._team_cache: Dict[Tuple[str, bool], TeamHtftProfile] = {}
+        self._league_cache: Dict[str, LeagueHtftProfile] = {}
+
+    def get_conn(self):
+        if self.conn is None or self.conn.closed:
+            dsn = get_clean_dsn()
+            self.conn = psycopg2.connect(dsn)
+        return self.conn
+
+    def _get_team_htft_profile(
+        self,
+        team_id: str,
+        is_home: bool,
+        before_date: Optional[int] = None,
+        limit: int = 30,
+    ) -> TeamHtftProfile:
+        """
+        Compute HT/FT profile for a team from their recent matches.
+
+        Args:
+            team_id: Team ID
+            is_home: True = only home matches, False = only away matches
+            before_date: Only use matches before this timestamp (ms UTC)
+            limit: Number of recent matches to consider
+        """
+        cache_key = (team_id, is_home, before_date)
+        if cache_key in self._team_cache:
+            return self._team_cache[cache_key]
+
+        conn = self.get_conn()
+        cur = conn.cursor()
+
+        if is_home:
+            query = """
+                SELECT ht_score_home, ht_score_away, score_home, score_away
+                FROM matches
+                WHERE home_team_id = %s
+                  AND sport = 'football'
+                  AND status = 'FT'
+                  AND ht_score_home IS NOT NULL
+                  AND ht_score_away IS NOT NULL
+            """
+        else:
+            query = """
+                SELECT ht_score_away, ht_score_home, score_away, score_home
+                FROM matches
+                WHERE away_team_id = %s
+                  AND sport = 'football'
+                  AND status = 'FT'
+                  AND ht_score_home IS NOT NULL
+                  AND ht_score_away IS NOT NULL
+            """
+
+        params = [team_id]
+
+        if before_date:
+            query += " AND mst_utc < %s"
+            params.append(before_date)
+
+        query += " ORDER BY mst_utc DESC LIMIT %s"
+        params.append(limit)
+
+        cur.execute(query, params)
+        rows = cur.fetchall()
+        cur.close()
+
+        profile = TeamHtftProfile()
+        profile.matches = len(rows)
+
+        for ht_mine, ht_opp, ft_mine, ft_opp in rows:
+            # 1st half scoring
+            if ht_mine > 0:
+                profile.ht_scored += 1
+            if ht_opp > 0:
+                profile.ht_conceded += 1
+
+            # HT situation
+            if ht_mine > ht_opp:
+                profile.ht_leading += 1
+            elif ht_mine < ht_opp:
+                profile.ht_trailing += 1
+                # Comeback
+                if ft_mine > ft_opp:
+                    profile.comeback_wins += 1
+
+            # Goal distribution
+            profile.goals_1h += ht_mine
+            profile.goals_2h += (ft_mine - ht_mine)
+            profile.conceded_1h += ht_opp
+            profile.conceded_2h += (ft_opp - ht_opp)
+
+        self._team_cache[cache_key] = profile
+        return profile
+
+    def _get_league_htft_profile(
+        self,
+        league_id: str,
+        before_date: Optional[int] = None,
+    ) -> LeagueHtftProfile:
+        """Compute HT/FT profile for a league."""
+        cache_key = (league_id, before_date)
+        if cache_key in self._league_cache:
+            return self._league_cache[cache_key]
+
+        conn = self.get_conn()
+        cur = conn.cursor()
+
+        query = """
+            SELECT ht_score_home, ht_score_away, score_home, score_away
+            FROM matches
+            WHERE league_id = %s
+              AND sport = 'football'
+              AND status = 'FT'
+              AND ht_score_home IS NOT NULL
+              AND ht_score_away IS NOT NULL
+        """
+        params = [league_id]
+
+        if before_date:
+            query += " AND mst_utc < %s"
+            params.append(before_date)
+
+        query += " ORDER BY mst_utc DESC LIMIT 500"
+        params_final = params
+
+        cur.execute(query, params_final)
+        rows = cur.fetchall()
+        cur.close()
+
+        profile = LeagueHtftProfile()
+        profile.matches = len(rows)
+
+        for hth, hta, sh, sa in rows:
+            profile.ht_goals_total += hth + hta
+            profile.ft_goals_total += sh + sa
+
+            # Classify HT/FT
+            ht = "1" if hth > hta else ("2" if hth < hta else "X")
+            ft = "1" if sh > sa else ("2" if sh < sa else "X")
+            htft = f"{ht}/{ft}"
+
+            profile.htft_counts[htft] = profile.htft_counts.get(htft, 0) + 1
+            if htft in ("1/2", "2/1"):
+                profile.reversals += 1
+
+        self._league_cache[cache_key] = profile
+        return profile
+
+    def get_features(
+        self,
+        home_team_id: str,
+        away_team_id: str,
+        league_id: Optional[str] = None,
+        before_date: Optional[int] = None,
+    ) -> Dict[str, float]:
+        """
+        Get HT/FT tendency features for a match.
+
+        Returns dict with ~15 features.
+        """
+        # Team profiles (home side for home team, away side for away team)
+        home_prof = self._get_team_htft_profile(home_team_id, is_home=True, before_date=before_date)
+        away_prof = self._get_team_htft_profile(away_team_id, is_home=False, before_date=before_date)
+
+        # League profile
+        league_prof = LeagueHtftProfile()
+        if league_id:
+            league_prof = self._get_league_htft_profile(league_id, before_date=before_date)
+
+        features = {
+            # Home team HT/FT tendencies
+            "htft_home_ht_scoring_rate": home_prof.ht_scoring_rate,
+            "htft_home_ht_concede_rate": home_prof.ht_concede_rate,
+            "htft_home_ht_win_rate": home_prof.ht_win_rate,
+            "htft_home_comeback_rate": home_prof.comeback_rate,
+            "htft_home_first_half_goal_pct": home_prof.first_half_goal_pct,
+            "htft_home_second_half_surge": min(home_prof.second_half_surge, 3.0),
+
+            # Away team HT/FT tendencies
+            "htft_away_ht_scoring_rate": away_prof.ht_scoring_rate,
+            "htft_away_ht_concede_rate": away_prof.ht_concede_rate,
+            "htft_away_ht_win_rate": away_prof.ht_win_rate,
+            "htft_away_comeback_rate": away_prof.comeback_rate,
+            "htft_away_first_half_goal_pct": away_prof.first_half_goal_pct,
+            "htft_away_second_half_surge": min(away_prof.second_half_surge, 3.0),
+
+            # League-level
+            "htft_league_avg_ht_goals": league_prof.avg_ht_goals,
+            "htft_league_reversal_rate": league_prof.reversal_rate,
+            "htft_league_first_half_pct": league_prof.first_half_pct,
+
+            # Data quality (how many matches we have for these features)
+            "htft_home_sample_size": min(home_prof.matches / 30.0, 1.0),
+            "htft_away_sample_size": min(away_prof.matches / 30.0, 1.0),
+        }
+
+        return features
+
+    def clear_cache(self):
+        """Clear internal caches (useful between batches)."""
+        self._team_cache.clear()
+        self._league_cache.clear()
+
+
+# Singleton
+_engine = None
+
+
+def get_htft_tendency_engine() -> HtftTendencyEngine:
+    global _engine
+    if _engine is None:
+        _engine = HtftTendencyEngine()
+    return _engine
+
+
+# ── Test ─────────────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    engine = get_htft_tendency_engine()
+
+    conn = engine.get_conn()
+    cur = conn.cursor()
+    cur.execute("""
+        SELECT home_team_id, away_team_id, league_id, mst_utc, match_name
+        FROM matches
+        WHERE sport = 'football' AND status = 'FT'
+          AND home_team_id IS NOT NULL AND away_team_id IS NOT NULL
+        ORDER BY mst_utc DESC LIMIT 3
+    """)
+    matches = cur.fetchall()
+    cur.close()
+
+    for hid, aid, lid, mst, name in matches:
+        print(f"\n🏟️  {name}")
+        features = engine.get_features(hid, aid, lid, mst)
+        for k, v in sorted(features.items()):
+            print(f"  {k}: {v:.4f}")
@@ -0,0 +1,434 @@
+"""
+Momentum Engine - Son Maç Trendleri
+V9 Model için takımların anlık form trendini analiz eder.
+
+Faktörler:
+1. Gol atma trendi (artan/azalan/stabil)
+2. Yenilmezlik/yenilgi serisi
+3. Son maç psikolojisi (büyük galibiyet/mağlubiyet etkisi)
+4. Ev/Deplasman momentum farkı
+"""
+
+import os
+import sys
+from typing import Dict, List, Tuple, Optional
+from dataclasses import dataclass, field
+
+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 MomentumData:
+    """Takım momentum verileri"""
+    goals_trend: float = 0.0          # -1 (azalan) to +1 (artan)
+    conceded_trend: float = 0.0       # -1 (azalan) to +1 (artan) [negatif iyi]
+    unbeaten_streak: int = 0          # Yenilmezlik serisi
+    losing_streak: int = 0            # Yenilgi serisi
+    winning_streak: int = 0           # Galibiyet serisi
+    last_match_impact: float = 0.0    # Son maç psikolojik etkisi (-1 to +1)
+    momentum_score: float = 0.0       # Toplam momentum (-1 to +1)
+    form_direction: str = "stable"    # "improving", "declining", "stable"
+    xg_underperformance: float = 0.0  # (xG_For - Real_Goals) in last matches (>0 means underperforming)
+    xg_conceded_diff: float = 0.0     # (Real_Conceded - xG_Against) in last matches
+
+
+class MomentumEngine:
+    """
+    Son maçlardaki trendi analiz eder.
+    Form yükselişi/düşüşü, seriler ve psikolojik etki.
+    """
+    
+    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"[MomentumEngine] 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 get_recent_matches(
+        self,
+        team_id: str,
+        before_date_ms: int,
+        limit: int = 5,
+        home_only: bool = False,
+        away_only: bool = False
+    ) -> List[Dict]:
+        """
+        Takımın son maçlarını getir.
+        
+        Returns:
+            List of matches with scores and home/away info
+        """
+        conn = self._get_conn()
+        if conn is None:
+            return []
+        
+        try:
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            
+            conditions = ["mst_utc < %s", "score_home IS NOT NULL"]
+            params = [before_date_ms]
+            
+            if home_only:
+                conditions.append("home_team_id = %s")
+                params.append(team_id)
+            elif away_only:
+                conditions.append("away_team_id = %s")
+                params.append(team_id)
+            else:
+                conditions.append("(home_team_id = %s OR away_team_id = %s)")
+                params.extend([team_id, team_id])
+            query = f"""
+            SELECT 
+                id, home_team_id, away_team_id,
+                score_home, score_away, mst_utc
+            FROM matches
+            WHERE {' AND '.join(conditions)}
+            ORDER BY mst_utc DESC
+            LIMIT %s
+            """
+            params.append(limit)
+            
+            cursor.execute(query, params)
+            return cursor.fetchall()
+            
+        except Exception as e:
+            print(f"[MomentumEngine] Query error: {e}")
+            return []
+    
+    def calculate_goals_trend(self, matches: List[Dict], team_id: str) -> Tuple[float, float]:
+        """
+        Gol atma ve yeme trendini hesapla.
+        Son 3 maç vs önceki 2 maç karşılaştırması.
+        
+        Returns:
+            (goals_trend, conceded_trend) - -1 to +1
+        """
+        if len(matches) < 3:
+            return 0.0, 0.0
+        
+        # Her maç için gol ve yenilen gol hesapla
+        goals = []
+        conceded = []
+        
+        for match in matches:
+            if match['home_team_id'] == team_id:
+                goals.append(match['score_home'])
+                conceded.append(match['score_away'])
+            else:
+                goals.append(match['score_away'])
+                conceded.append(match['score_home'])
+        
+        # Son 3 vs önceki maçlar
+        recent_goals = sum(goals[:3]) / 3 if len(goals) >= 3 else 0
+        older_goals = sum(goals[3:]) / len(goals[3:]) if len(goals) > 3 else recent_goals
+        
+        recent_conceded = sum(conceded[:3]) / 3 if len(conceded) >= 3 else 0
+        older_conceded = sum(conceded[3:]) / len(conceded[3:]) if len(conceded) > 3 else recent_conceded
+        
+        # Trend hesapla (-1 to +1)
+        goals_trend = min(max((recent_goals - older_goals) / 2, -1), 1)
+        conceded_trend = min(max((recent_conceded - older_conceded) / 2, -1), 1)
+        
+        return goals_trend, conceded_trend
+    
+    def calculate_streaks(self, matches: List[Dict], team_id: str) -> Tuple[int, int, int]:
+        """
+        Galibiyet, yenilmezlik ve yenilgi serilerini hesapla.
+        
+        Returns:
+            (winning_streak, unbeaten_streak, losing_streak)
+        """
+        winning = 0
+        unbeaten = 0
+        losing = 0
+        
+        for match in matches:
+            # Sonucu belirle
+            if match['home_team_id'] == team_id:
+                goals_for = match['score_home']
+                goals_against = match['score_away']
+            else:
+                goals_for = match['score_away']
+                goals_against = match['score_home']
+            
+            if goals_for > goals_against:  # Galibiyet
+                if losing == 0:  # Henüz yenilgi serisi başlamamış
+                    winning += 1
+                    unbeaten += 1
+                else:
+                    break
+            elif goals_for == goals_against:  # Beraberlik
+                if losing == 0:
+                    winning = 0  # Galibiyet serisi bitti
+                    unbeaten += 1
+                else:
+                    break
+            else:  # Yenilgi
+                if winning > 0 or unbeaten > 0:
+                    winning = 0
+                    unbeaten = 0
+                losing += 1
+        
+        return winning, unbeaten, losing
+    
+    def calculate_last_match_impact(self, matches: List[Dict], team_id: str) -> float:
+        """
+        Son maçın psikolojik etkisini hesapla.
+        Büyük galibiyet = +1, büyük mağlubiyet = -1
+        
+        Returns:
+            impact score: -1 to +1
+        """
+        if not matches:
+            return 0.0
+        
+        last_match = matches[0]
+        
+        if last_match['home_team_id'] == team_id:
+            goals_for = last_match['score_home']
+            goals_against = last_match['score_away']
+        else:
+            goals_for = last_match['score_away']
+            goals_against = last_match['score_home']
+        
+        goal_diff = goals_for - goals_against
+        
+        # Gol farkına göre etki
+        if goal_diff >= 4:
+            return 1.0  # Çok büyük galibiyet
+        elif goal_diff >= 2:
+            return 0.6
+        elif goal_diff == 1:
+            return 0.3
+        elif goal_diff == 0:
+            return 0.0
+        elif goal_diff == -1:
+            return -0.3
+        elif goal_diff >= -3:
+            return -0.6
+        else:
+            return -1.0  # Çok büyük mağlubiyet
+            
+    def calculate_xg_underperformance(self, matches: List[Dict], team_id: str) -> Tuple[float, float]:
+        """
+        Calculate if a team chronically underperforms its xG (Expected Goals).
+        Returns:
+            (xg_strike_diff, xg_defend_diff)
+            xg_strike_diff: > 0 means they score LESS than expected (Bad Finishers)
+            xg_defend_diff: > 0 means they concede MORE than expected (Bad Goalkeeper/Luck)
+        """
+        if not matches:
+            return 0.0, 0.0
+            
+        real_scored = 0
+        xg_created = 0.0
+        
+        real_conceded = 0
+        xg_conceded = 0.0
+        
+        for m in matches:
+            is_home = (m['home_team_id'] == team_id)
+            if is_home:
+                real_scored += m['score_home']
+                real_conceded += m['score_away']
+                # Create synthetic xG data (mock based on score for demo since stats table absent)
+                xg_created += max(0.5, m['score_home'] * 1.5 - 0.5) 
+                xg_conceded += max(0.5, m['score_away'] * 1.5 - 0.5)
+            else:
+                real_scored += m['score_away']
+                real_conceded += m['score_home']
+                xg_created += max(0.5, m['score_away'] * 1.5 - 0.5)
+                xg_conceded += max(0.5, m['score_home'] * 1.5 - 0.5)
+                
+        # Calculate per match diffs
+        match_count = len(matches)
+        
+        xg_strike_diff = (xg_created - real_scored) / match_count if match_count else 0
+        xg_defend_diff = (real_conceded - xg_conceded) / match_count if match_count else 0
+        
+        return xg_strike_diff, xg_defend_diff
+    
+    def calculate_momentum(
+        self,
+        team_id: str,
+        before_date_ms: int,
+        match_limit: int = 5
+    ) -> MomentumData:
+        """
+        Takımın tam momentum analizini yap.
+        
+        Returns:
+            MomentumData with all metrics
+        """
+        data = MomentumData()
+        
+        matches = self.get_recent_matches(team_id, before_date_ms, match_limit)
+        
+        if not matches:
+            return data
+        
+        # 1. Gol trendi
+        data.goals_trend, data.conceded_trend = self.calculate_goals_trend(matches, team_id)
+        
+        # 2. Seriler
+        data.winning_streak, data.unbeaten_streak, data.losing_streak = \
+            self.calculate_streaks(matches, team_id)
+        
+        # 3. Son maç etkisi
+        data.last_match_impact = self.calculate_last_match_impact(matches, team_id)
+        
+        # 4. Form yönü belirleme
+        if data.goals_trend > 0.3 and data.conceded_trend < 0:
+            data.form_direction = "improving"
+        elif data.goals_trend < -0.3 or data.conceded_trend > 0.3:
+            data.form_direction = "declining"
+        else:
+            data.form_direction = "stable"
+            
+        # 5. xG Underperformance (Chronik beceriksizlik)
+        data.xg_underperformance, data.xg_conceded_diff = self.calculate_xg_underperformance(matches, team_id)
+        
+        # 6. Toplam momentum skoru
+        momentum = 0.0
+        
+        # Gol trendi + savunma trendi (ters çevrilmiş)
+        momentum += data.goals_trend * 0.25
+        momentum += (-data.conceded_trend) * 0.20
+        
+        # Seri bonusları
+        if data.winning_streak >= 3:
+            momentum += 0.25
+        elif data.winning_streak >= 2:
+            momentum += 0.15
+        elif data.unbeaten_streak >= 5:
+            momentum += 0.15
+        
+        if data.losing_streak >= 3:
+            momentum -= 0.30
+        elif data.losing_streak >= 2:
+            momentum -= 0.15
+        
+        # Son maç etkisi
+        momentum += data.last_match_impact * 0.20
+        
+        # Ceza: xG Underperformance Penalty (Beceriksizlik Cezası)
+        # Eğer takım attığından çok xG üretiyorsa (- puan)
+        if data.xg_underperformance > 0.5: # Maç başı 0.5 gol eksik atıyor!
+            momentum -= min(0.3, data.xg_underperformance * 0.2)
+            
+        # Ceza: xG Defend Underperformance (Kötü kaleci Cezası)
+        # Eğer beklenenden çok gol yiyorsa
+        if data.xg_conceded_diff > 0.5:
+            momentum -= min(0.3, data.xg_conceded_diff * 0.2)
+        
+        data.momentum_score = min(max(momentum, -1), 1)
+        
+        return data
+    
+    def get_features(
+        self,
+        home_team_id: str,
+        away_team_id: str,
+        match_date_ms: int
+    ) -> Dict[str, float]:
+        """
+        Model için feature dict döndür.
+        """
+        home_momentum = self.calculate_momentum(home_team_id, match_date_ms)
+        away_momentum = self.calculate_momentum(away_team_id, match_date_ms)
+        
+        # Form direction encoding
+        direction_map = {"improving": 1, "stable": 0, "declining": -1}
+        
+        return {
+            # Ev sahibi momentum
+            "home_momentum_score": home_momentum.momentum_score,
+            "home_goals_trend": home_momentum.goals_trend,
+            "home_conceded_trend": home_momentum.conceded_trend,
+            "home_winning_streak": min(home_momentum.winning_streak, 5),
+            "home_unbeaten_streak": min(home_momentum.unbeaten_streak, 10),
+            "home_losing_streak": min(home_momentum.losing_streak, 5),
+            "home_last_impact": home_momentum.last_match_impact,
+            "home_form_direction": direction_map.get(home_momentum.form_direction, 0),
+            "home_xg_underperf": home_momentum.xg_underperformance,
+            "home_xg_conceded_diff": home_momentum.xg_conceded_diff,
+            
+            # Deplasman momentum
+            "away_momentum_score": away_momentum.momentum_score,
+            "away_goals_trend": away_momentum.goals_trend,
+            "away_conceded_trend": away_momentum.conceded_trend,
+            "away_winning_streak": min(away_momentum.winning_streak, 5),
+            "away_unbeaten_streak": min(away_momentum.unbeaten_streak, 10),
+            "away_losing_streak": min(away_momentum.losing_streak, 5),
+            "away_last_impact": away_momentum.last_match_impact,
+            "away_form_direction": direction_map.get(away_momentum.form_direction, 0),
+            "away_xg_underperf": away_momentum.xg_underperformance,
+            "away_xg_conceded_diff": away_momentum.xg_conceded_diff,
+            
+            # Farklar
+            "momentum_diff": home_momentum.momentum_score - away_momentum.momentum_score,
+            "trend_diff": (home_momentum.goals_trend - home_momentum.conceded_trend) - 
+                          (away_momentum.goals_trend - away_momentum.conceded_trend),
+            "xg_underperf_diff": home_momentum.xg_underperformance - away_momentum.xg_underperformance,
+        }
+
+
+# Singleton instance
+_engine_instance = None
+
+def get_momentum_engine() -> MomentumEngine:
+    """Singleton pattern ile engine döndür"""
+    global _engine_instance
+    if _engine_instance is None:
+        _engine_instance = MomentumEngine()
+    return _engine_instance
+
+
+# Test
+if __name__ == "__main__":
+    engine = get_momentum_engine()
+    
+    # Test data
+    print("=" * 60)
+    print("MOMENTUM ENGINE TEST")
+    print("=" * 60)
+    
+    # Örnek hesaplama (DB olmadan)
+    data = MomentumData(
+        goals_trend=0.5,
+        conceded_trend=-0.3,
+        winning_streak=3,
+        unbeaten_streak=5,
+        losing_streak=0,
+        last_match_impact=0.6,
+        form_direction="improving"
+    )
+    
+    print(f"Goals Trend: {data.goals_trend}")
+    print(f"Conceded Trend: {data.conceded_trend}")
+    print(f"Winning Streak: {data.winning_streak}")
+    print(f"Unbeaten Streak: {data.unbeaten_streak}")
+    print(f"Form Direction: {data.form_direction}")
+    print(f"Last Match Impact: {data.last_match_impact}")
@@ -0,0 +1,371 @@
+"""
+Poisson Engine - Matematiksel Gol Modeli
+V9 Model için Poisson dağılımı ile gol olasılıkları hesaplar.
+
+Özellikler:
+1. Exact score olasılıkları (0-0, 1-0, 1-1, 2-1, vb.)
+2. Over/Under olasılıkları (matematiksel)
+3. BTTS (Karşılıklı Gol) olasılıkları
+4. Expected Goals (xG) tahmini
+"""
+
+import math
+from typing import Dict, Tuple, Optional
+from dataclasses import dataclass, field
+
+
+def poisson_prob(lam: float, k: int) -> float:
+    """
+    Poisson olasılık formülü.
+    P(X = k) = (λ^k * e^(-λ)) / k!
+    """
+    if lam <= 0:
+        return 1.0 if k == 0 else 0.0
+    return (math.pow(lam, k) * math.exp(-lam)) / math.factorial(k)
+
+
+@dataclass
+class PoissonPrediction:
+    """Poisson tahmin sonuçları"""
+    home_xg: float = 0.0           # Ev sahibi beklenen gol
+    away_xg: float = 0.0           # Deplasman beklenen gol
+    total_xg: float = 0.0          # Toplam beklenen gol
+    
+    # Maç sonucu olasılıkları
+    home_win_prob: float = 0.0
+    draw_prob: float = 0.0
+    away_win_prob: float = 0.0
+    
+    # Alt/Üst olasılıkları
+    over_15_prob: float = 0.0
+    over_25_prob: float = 0.0
+    over_35_prob: float = 0.0
+    under_15_prob: float = 0.0
+    under_25_prob: float = 0.0
+    under_35_prob: float = 0.0
+    
+    # BTTS
+    btts_yes_prob: float = 0.0
+    btts_no_prob: float = 0.0
+    
+    # En olası skorlar
+    most_likely_scores: list = field(default_factory=list)
+
+
+class PoissonEngine:
+    """
+    Poisson dağılımı ile gol olasılıkları hesaplar.
+    İstatistiksel bir yaklaşım - machine learning'den bağımsız.
+    """
+    
+    # Lig bazlı ortalama gol verileri (varsayılan değerler)
+    DEFAULT_HOME_XG = 1.45
+    DEFAULT_AWAY_XG = 1.15
+    DEFAULT_LEAGUE_AVG = 2.60
+    
+    def __init__(self):
+        self.max_goals = 7  # Hesaplama için maksimum gol sayısı
+    
+    def calculate_xg(
+        self,
+        home_goals_avg: float,
+        home_conceded_avg: float,
+        away_goals_avg: float,
+        away_conceded_avg: float,
+        league_home_avg: float = None,
+        league_away_avg: float = None,
+        league_total_avg: float = None
+    ) -> Tuple[float, float]:
+        """
+        Beklenen gol (xG) hesapla.
+        
+        Attack strength * Defense weakness * League average
+        """
+        # Varsayılan lig ortalamaları
+        if league_home_avg is None:
+            league_home_avg = self.DEFAULT_HOME_XG
+        if league_away_avg is None:
+            league_away_avg = self.DEFAULT_AWAY_XG
+        if league_total_avg is None:
+            league_total_avg = self.DEFAULT_LEAGUE_AVG
+        
+        # Güç hesaplamaları
+        # Ev sahibi saldırı gücü = Ev gol ortalaması / Lig ev gol ortalaması
+        home_attack = home_goals_avg / league_home_avg if league_home_avg > 0 else 1.0
+        # Deplasman savunma zayıflığı = Deplasman yenilen gol / Lig deplasman yenilen
+        away_defense = away_conceded_avg / league_away_avg if league_away_avg > 0 else 1.0
+        
+        # Deplasman saldırı gücü
+        away_attack = away_goals_avg / league_away_avg if league_away_avg > 0 else 1.0
+        # Ev sahibi savunma zayıflığı
+        home_defense = home_conceded_avg / league_home_avg if league_home_avg > 0 else 1.0
+        
+        # Expected Goals
+        home_xg = home_attack * away_defense * league_home_avg
+        away_xg = away_attack * home_defense * league_away_avg
+        
+        # Aşırı değerleri sınırla
+        home_xg = max(0.3, min(home_xg, 4.0))
+        away_xg = max(0.2, min(away_xg, 3.5))
+        
+        return home_xg, away_xg
+    
+    def calculate_score_matrix(
+        self, 
+        home_xg: float, 
+        away_xg: float
+    ) -> Dict[Tuple[int, int], float]:
+        """
+        Tüm skor kombinasyonlarının olasılıklarını hesapla.
+        
+        Returns:
+            Dict[(home_goals, away_goals)] = probability
+        """
+        matrix = {}
+        
+        for home_goals in range(self.max_goals + 1):
+            for away_goals in range(self.max_goals + 1):
+                prob = poisson_prob(home_xg, home_goals) * poisson_prob(away_xg, away_goals)
+                matrix[(home_goals, away_goals)] = prob
+        
+        return matrix
+    
+    def calculate_match_odds(
+        self,
+        home_xg: float,
+        away_xg: float
+    ) -> Tuple[float, float, float]:
+        """
+        1X2 olasılıklarını hesapla.
+        
+        Returns:
+            (home_win, draw, away_win) probabilities
+        """
+        matrix = self.calculate_score_matrix(home_xg, away_xg)
+        
+        home_win = 0.0
+        draw = 0.0
+        away_win = 0.0
+        
+        for (h, a), prob in matrix.items():
+            if h > a:
+                home_win += prob
+            elif h == a:
+                draw += prob
+            else:
+                away_win += prob
+        
+        # Normalize (toplam 1 olmalı)
+        total = home_win + draw + away_win
+        if total > 0:
+            home_win /= total
+            draw /= total
+            away_win /= total
+        
+        return home_win, draw, away_win
+    
+    def calculate_over_under(
+        self,
+        home_xg: float,
+        away_xg: float
+    ) -> Dict[str, float]:
+        """
+        Alt/Üst olasılıklarını hesapla.
+        """
+        matrix = self.calculate_score_matrix(home_xg, away_xg)
+        
+        over_15 = 0.0
+        over_25 = 0.0
+        over_35 = 0.0
+        
+        for (h, a), prob in matrix.items():
+            total = h + a
+            if total > 1.5:
+                over_15 += prob
+            if total > 2.5:
+                over_25 += prob
+            if total > 3.5:
+                over_35 += prob
+        
+        return {
+            "over_15": over_15,
+            "over_25": over_25,
+            "over_35": over_35,
+            "under_15": 1 - over_15,
+            "under_25": 1 - over_25,
+            "under_35": 1 - over_35,
+        }
+    
+    def calculate_btts(
+        self,
+        home_xg: float,
+        away_xg: float
+    ) -> Tuple[float, float]:
+        """
+        Karşılıklı Gol (Both Teams To Score) olasılığı.
+        """
+        # P(Home scores at least 1) = 1 - P(Home scores 0)
+        home_scores = 1 - poisson_prob(home_xg, 0)
+        # P(Away scores at least 1) = 1 - P(Away scores 0)
+        away_scores = 1 - poisson_prob(away_xg, 0)
+        
+        # P(BTTS) = P(Home scores) * P(Away scores)
+        btts_yes = home_scores * away_scores
+        btts_no = 1 - btts_yes
+        
+        return btts_yes, btts_no
+    
+    def get_most_likely_scores(
+        self,
+        home_xg: float,
+        away_xg: float,
+        top_n: int = 5
+    ) -> list:
+        """
+        En olası skorları getir.
+        """
+        matrix = self.calculate_score_matrix(home_xg, away_xg)
+        
+        # Olasılığa göre sırala
+        sorted_scores = sorted(matrix.items(), key=lambda x: x[1], reverse=True)
+        
+        return [
+            {"score": f"{h}-{a}", "probability": round(prob * 100, 1)}
+            for (h, a), prob in sorted_scores[:top_n]
+        ]
+    
+    def predict(
+        self,
+        home_goals_avg: float,
+        home_conceded_avg: float,
+        away_goals_avg: float,
+        away_conceded_avg: float,
+        league_home_avg: float = None,
+        league_away_avg: float = None,
+        league_total_avg: float = None
+    ) -> PoissonPrediction:
+        """
+        Tam Poisson tahmini.
+        """
+        prediction = PoissonPrediction()
+        
+        # 1. xG hesapla
+        home_xg, away_xg = self.calculate_xg(
+            home_goals_avg, home_conceded_avg,
+            away_goals_avg, away_conceded_avg,
+            league_home_avg, league_away_avg, league_total_avg
+        )
+        
+        prediction.home_xg = round(home_xg, 2)
+        prediction.away_xg = round(away_xg, 2)
+        prediction.total_xg = round(home_xg + away_xg, 2)
+        
+        # 2. Maç sonucu
+        hw, d, aw = self.calculate_match_odds(home_xg, away_xg)
+        prediction.home_win_prob = round(hw, 3)
+        prediction.draw_prob = round(d, 3)
+        prediction.away_win_prob = round(aw, 3)
+        
+        # 3. Alt/Üst
+        ou = self.calculate_over_under(home_xg, away_xg)
+        prediction.over_15_prob = round(ou["over_15"], 3)
+        prediction.over_25_prob = round(ou["over_25"], 3)
+        prediction.over_35_prob = round(ou["over_35"], 3)
+        prediction.under_15_prob = round(ou["under_15"], 3)
+        prediction.under_25_prob = round(ou["under_25"], 3)
+        prediction.under_35_prob = round(ou["under_35"], 3)
+        
+        # 4. BTTS
+        btts_yes, btts_no = self.calculate_btts(home_xg, away_xg)
+        prediction.btts_yes_prob = round(btts_yes, 3)
+        prediction.btts_no_prob = round(btts_no, 3)
+        
+        # 5. En olası skorlar
+        prediction.most_likely_scores = self.get_most_likely_scores(home_xg, away_xg)
+        
+        return prediction
+    
+    def get_features(
+        self,
+        home_goals_avg: float,
+        home_conceded_avg: float,
+        away_goals_avg: float,
+        away_conceded_avg: float,
+        league_home_avg: float = None,
+        league_away_avg: float = None,
+        league_total_avg: float = None
+    ) -> Dict[str, float]:
+        """
+        Model için feature dict.
+        """
+        pred = self.predict(
+            home_goals_avg, home_conceded_avg,
+            away_goals_avg, away_conceded_avg,
+            league_home_avg, league_away_avg, league_total_avg
+        )
+        
+        return {
+            "poisson_home_xg": pred.home_xg,
+            "poisson_away_xg": pred.away_xg,
+            "poisson_total_xg": pred.total_xg,
+            "poisson_home_win": pred.home_win_prob,
+            "poisson_draw": pred.draw_prob,
+            "poisson_away_win": pred.away_win_prob,
+            "poisson_over_15": pred.over_15_prob,
+            "poisson_over_25": pred.over_25_prob,
+            "poisson_over_35": pred.over_35_prob,
+            "poisson_btts_yes": pred.btts_yes_prob,
+        }
+
+
+# Singleton
+_engine_instance = None
+
+def get_poisson_engine() -> PoissonEngine:
+    """Singleton pattern"""
+    global _engine_instance
+    if _engine_instance is None:
+        _engine_instance = PoissonEngine()
+    return _engine_instance
+
+
+# Test
+if __name__ == "__main__":
+    engine = get_poisson_engine()
+    
+    # Örnek: Güçlü ev sahibi vs zayıf deplasman
+    print("=" * 60)
+    print("POISSON ENGINE TEST")
+    print("Galatasaray (ev) vs Antalyaspor (deplasman)")
+    print("=" * 60)
+    
+    pred = engine.predict(
+        home_goals_avg=2.1,      # GS ev ortalaması
+        home_conceded_avg=0.8,   # GS ev yenilen
+        away_goals_avg=0.9,      # Antalya deplasman gol
+        away_conceded_avg=1.8,   # Antalya deplasman yenilen
+        league_home_avg=1.5,
+        league_away_avg=1.1
+    )
+    
+    print(f"\n📊 Expected Goals:")
+    print(f"   Ev Sahibi xG: {pred.home_xg}")
+    print(f"   Deplasman xG: {pred.away_xg}")
+    print(f"   Toplam xG: {pred.total_xg}")
+    
+    print(f"\n🎯 Maç Sonucu:")
+    print(f"   1 (Ev): {pred.home_win_prob*100:.1f}%")
+    print(f"   X (Beraberlik): {pred.draw_prob*100:.1f}%")
+    print(f"   2 (Deplasman): {pred.away_win_prob*100:.1f}%")
+    
+    print(f"\n⚽ Alt/Üst:")
+    print(f"   2.5 Üst: {pred.over_25_prob*100:.1f}%")
+    print(f"   2.5 Alt: {pred.under_25_prob*100:.1f}%")
+    
+    print(f"\n🤝 Karşılıklı Gol:")
+    print(f"   KG Var: {pred.btts_yes_prob*100:.1f}%")
+    print(f"   KG Yok: {pred.btts_no_prob*100:.1f}%")
+    
+    print(f"\n📈 En Olası Skorlar:")
+    for score_data in pred.most_likely_scores:
+        print(f"   {score_data['score']}: {score_data['probability']}%")
@@ -0,0 +1,368 @@
+"""
+Referee Engine - V9 Feature
+Hakem profilleri ve maç etki analizi.
+
+Analiz Edilen Metrikler:
+- Ortalama kart sayısı (sarı/kırmızı)
+- Penaltı verme eğilimi
+- Ev sahibi lehine karar oranı
+- Maç başına toplam gol ortalaması
+"""
+
+import os
+from typing import Dict, Optional, List
+from dataclasses import dataclass, field
+from datetime import datetime
+
+try:
+    import psycopg2
+    from psycopg2.extras import RealDictCursor
+except ImportError:
+    psycopg2 = None
+
+
+@dataclass
+class RefereeProfile:
+    """Hakem profili"""
+    referee_name: str
+    matches_count: int = 0
+    
+    # Kart istatistikleri
+    avg_yellow_cards: float = 0.0
+    avg_red_cards: float = 0.0
+    total_cards_per_match: float = 0.0
+    
+    # Penaltı istatistikleri
+    penalty_rate: float = 0.0  # Penaltı verdiği maç oranı
+    
+    # Ev sahibi eğilimi
+    home_win_rate: float = 0.0
+    home_bias: float = 0.0  # -1 (away bias) to +1 (home bias)
+    
+    # Gol istatistikleri
+    avg_goals_per_match: float = 0.0
+    over_25_rate: float = 0.0
+
+
+@dataclass
+class RefereeFeatures:
+    """Model için hakem feature'ları"""
+    referee_name: str = ""
+    referee_matches: int = 0
+    referee_avg_yellow: float = 0.0
+    referee_avg_red: float = 0.0
+    referee_cards_total: float = 0.0
+    referee_penalty_rate: float = 0.0
+    referee_home_bias: float = 0.0
+    referee_avg_goals: float = 0.0
+    referee_over25_rate: float = 0.0
+    referee_experience: float = 0.0  # 0-1 normalized
+    
+    def to_dict(self) -> Dict[str, float]:
+        return {
+            'referee_matches': float(self.referee_matches),
+            'referee_avg_yellow': self.referee_avg_yellow,
+            'referee_avg_red': self.referee_avg_red,
+            'referee_cards_total': self.referee_cards_total,
+            'referee_penalty_rate': self.referee_penalty_rate,
+            'referee_home_bias': self.referee_home_bias,
+            'referee_avg_goals': self.referee_avg_goals,
+            'referee_over25_rate': self.referee_over25_rate,
+            'referee_experience': self.referee_experience,
+        }
+
+
+class RefereeEngine:
+    """
+    Hakem analiz motoru.
+    
+    Hakemlerin geçmiş maçlarını analiz ederek:
+    - Kart eğilimlerini
+    - Ev sahibi bias'ını
+    - Gol ortalamasını
+    hesaplar.
+    """
+    
+    # Ana hakem rolü ID'si (genellikle 1 veya "Hakem")
+    MAIN_REFEREE_ROLE_ID = 1
+    
+    def __init__(self):
+        self.conn = None
+        self._referee_cache: Dict[str, RefereeProfile] = {}
+        self._cache_loaded = False
+    
+    def _connect_db(self):
+        if psycopg2 is None:
+            return None
+        try:
+            from data.db import get_clean_dsn
+            self.conn = psycopg2.connect(get_clean_dsn())
+            return self.conn
+        except Exception as e:
+            print(f"[RefereeEngine] DB connection failed: {e}")
+            return None
+    
+    def get_conn(self):
+        if self.conn is None or self.conn.closed:
+            self._connect_db()
+        return self.conn
+    
+    def _get_main_referee_role_id(self) -> int:
+        """Ana hakem rolü ID'sini bul"""
+        conn = self.get_conn()
+        if conn is None:
+            return self.MAIN_REFEREE_ROLE_ID
+        
+        try:
+            with conn.cursor() as cur:
+                cur.execute("""
+                    SELECT id FROM official_roles 
+                    WHERE LOWER(name) LIKE '%%hakem%%' 
+                      AND LOWER(name) NOT LIKE '%%yardımcı%%'
+                      AND LOWER(name) NOT LIKE '%%dördüncü%%'
+                    LIMIT 1
+                """)
+                result = cur.fetchone()
+                if result:
+                    return result[0]
+        except Exception:
+            pass
+        
+        return self.MAIN_REFEREE_ROLE_ID
+    
+    def get_referee_for_match(self, match_id: str) -> Optional[str]:
+        """Maçın ana hakemini bul"""
+        conn = self.get_conn()
+        if conn is None:
+            return None
+        
+        try:
+            main_role_id = self._get_main_referee_role_id()
+            
+            with conn.cursor() as cur:
+                cur.execute("""
+                    SELECT name FROM match_officials
+                    WHERE match_id = %s AND role_id = %s
+                    LIMIT 1
+                """, (match_id, main_role_id))
+                result = cur.fetchone()
+                return result[0] if result else None
+        except Exception as e:
+            print(f"[RefereeEngine] Error getting referee: {e}")
+            return None
+    
+    def calculate_referee_profile(self, referee_name: str, league_id: str = None) -> RefereeProfile:
+        """Hakemin maçlarını analiz et. league_id verilirse sadece o ligteki maçları kullanır."""
+        
+        # Composite cache key — aynı isim farklı liglerde farklı profil
+        cache_key = (referee_name, league_id)
+        if cache_key in self._referee_cache:
+            return self._referee_cache[cache_key]
+        
+        profile = RefereeProfile(referee_name=referee_name)
+        
+        conn = self.get_conn()
+        if conn is None:
+            return profile
+        
+        try:
+            main_role_id = self._get_main_referee_role_id()
+            
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                # Bu hakemin yönettiği maçları al (league_id varsa sadece o lig)
+                if league_id:
+                    cur.execute("""
+                        SELECT m.id, m.score_home, m.score_away, m.home_team_id, m.away_team_id
+                        FROM matches m
+                        JOIN match_officials mo ON m.id = mo.match_id
+                        WHERE mo.name = %s 
+                          AND mo.role_id = %s
+                          AND m.league_id = %s
+                          AND m.score_home IS NOT NULL 
+                          AND m.score_away IS NOT NULL
+                        ORDER BY m.mst_utc DESC
+                        LIMIT 100
+                    """, (referee_name, main_role_id, league_id))
+                else:
+                    cur.execute("""
+                        SELECT m.id, m.score_home, m.score_away, m.home_team_id, m.away_team_id
+                        FROM matches m
+                        JOIN match_officials mo ON m.id = mo.match_id
+                        WHERE mo.name = %s 
+                          AND mo.role_id = %s
+                          AND m.score_home IS NOT NULL 
+                          AND m.score_away IS NOT NULL
+                        ORDER BY m.mst_utc DESC
+                        LIMIT 100
+                    """, (referee_name, main_role_id))
+                
+                matches = cur.fetchall()
+                profile.matches_count = len(matches)
+                
+                if profile.matches_count == 0:
+                    return profile
+                
+                match_ids = [m['id'] for m in matches]
+                
+                # Kart istatistikleri
+                cur.execute("""
+                    SELECT 
+                        COUNT(*) FILTER (WHERE event_subtype ILIKE '%%yellow%%') as yellow_count,
+                        COUNT(*) FILTER (WHERE event_subtype ILIKE '%%red%%' OR event_subtype ILIKE '%%second%%') as red_count
+                    FROM match_player_events
+                    WHERE match_id = ANY(%s) AND event_type = 'card'
+                """, (match_ids,))
+                
+                card_stats = cur.fetchone()
+                if card_stats:
+                    profile.avg_yellow_cards = (card_stats['yellow_count'] or 0) / profile.matches_count
+                    profile.avg_red_cards = (card_stats['red_count'] or 0) / profile.matches_count
+                    profile.total_cards_per_match = profile.avg_yellow_cards + profile.avg_red_cards
+                
+                # Penaltı istatistikleri
+                cur.execute("""
+                    SELECT COUNT(DISTINCT match_id) as penalty_matches
+                    FROM match_player_events
+                    WHERE match_id = ANY(%s) 
+                      AND event_type = 'goal' 
+                      AND event_subtype ILIKE '%%penaltı%%'
+                """, (match_ids,))
+                
+                penalty_stats = cur.fetchone()
+                if penalty_stats:
+                    profile.penalty_rate = (penalty_stats['penalty_matches'] or 0) / profile.matches_count
+                
+                # Ev sahibi eğilimi ve gol ortalaması
+                home_wins = 0
+                away_wins = 0
+                draws = 0
+                total_goals = 0
+                over_25_count = 0
+                
+                for m in matches:
+                    goals = (m['score_home'] or 0) + (m['score_away'] or 0)
+                    total_goals += goals
+                    
+                    if goals > 2.5:
+                        over_25_count += 1
+                    
+                    if m['score_home'] > m['score_away']:
+                        home_wins += 1
+                    elif m['score_home'] < m['score_away']:
+                        away_wins += 1
+                    else:
+                        draws += 1
+                
+                profile.avg_goals_per_match = total_goals / profile.matches_count
+                profile.over_25_rate = over_25_count / profile.matches_count
+                profile.home_win_rate = home_wins / profile.matches_count
+                
+                # Home bias: -1 (away favors) to +1 (home favors)
+                # Normal lig ortalaması ~%46 ev sahibi, buna göre normalize
+                expected_home_rate = 0.46
+                profile.home_bias = (profile.home_win_rate - expected_home_rate) * 2
+                profile.home_bias = max(-1, min(1, profile.home_bias))
+            
+            # Cache'e ekle
+            self._referee_cache[cache_key] = profile
+            return profile
+            
+        except Exception as e:
+            print(f"[RefereeEngine] Error calculating profile: {e}")
+            return profile
+    
+    def get_features(self, match_id: str, league_id: str = None) -> Dict[str, float]:
+        """
+        Maç için hakem feature'larını hesapla.
+        
+        Args:
+            match_id: Maç ID'si
+            league_id: Lig ID'si (opsiyonel — isim çakışmalarını önlemek için)
+            
+        Returns:
+            Hakem feature'ları dict olarak
+        """
+        features = RefereeFeatures()
+        
+        # Hakemi bul
+        referee_name = self.get_referee_for_match(match_id)
+        if referee_name is None:
+            return features.to_dict()
+        
+        features.referee_name = referee_name
+        
+        # Profili hesapla (league_id ile scope'lanmış)
+        profile = self.calculate_referee_profile(referee_name, league_id=league_id)
+        
+        features.referee_matches = profile.matches_count
+        features.referee_avg_yellow = profile.avg_yellow_cards
+        features.referee_avg_red = profile.avg_red_cards
+        features.referee_cards_total = profile.total_cards_per_match
+        features.referee_penalty_rate = profile.penalty_rate
+        features.referee_home_bias = profile.home_bias
+        features.referee_avg_goals = profile.avg_goals_per_match
+        features.referee_over25_rate = profile.over_25_rate
+        
+        # Deneyim: 50+ maç = 1.0, 0 maç = 0.0
+        features.referee_experience = min(profile.matches_count / 50, 1.0)
+        
+        return features.to_dict()
+    
+    def get_features_by_name(self, referee_name: str, league_id: str = None) -> Dict[str, float]:
+        """
+        Hakem ismiyle feature'ları hesapla.
+        
+        Args:
+            referee_name: Hakem ismi
+            league_id: Lig ID'si (opsiyonel — isim çakışmalarını önlemek için)
+            
+        Returns:
+            Hakem feature'ları dict olarak
+        """
+        features = RefereeFeatures()
+        
+        if not referee_name:
+            return features.to_dict()
+        
+        features.referee_name = referee_name
+        profile = self.calculate_referee_profile(referee_name, league_id=league_id)
+        
+        features.referee_matches = profile.matches_count
+        features.referee_avg_yellow = profile.avg_yellow_cards
+        features.referee_avg_red = profile.avg_red_cards
+        features.referee_cards_total = profile.total_cards_per_match
+        features.referee_penalty_rate = profile.penalty_rate
+        features.referee_home_bias = profile.home_bias
+        features.referee_avg_goals = profile.avg_goals_per_match
+        features.referee_over25_rate = profile.over_25_rate
+        features.referee_experience = min(profile.matches_count / 50, 1.0)
+        
+        return features.to_dict()
+
+
+# Singleton instance
+_engine: Optional[RefereeEngine] = None
+
+
+def get_referee_engine() -> RefereeEngine:
+    """Singleton referee engine instance döndür"""
+    global _engine
+    if _engine is None:
+        _engine = RefereeEngine()
+    return _engine
+
+
+if __name__ == "__main__":
+    # Test
+    engine = get_referee_engine()
+    
+    print("\n🧪 Referee Engine Test")
+    print("=" * 50)
+    
+    # Test with a known referee name
+    test_referee = "Cüneyt Çakır"
+    features = engine.get_features_by_name(test_referee)
+    
+    print(f"\n📊 Hakem: {test_referee}")
+    for key, value in features.items():
+        print(f"   {key}: {value:.3f}")
@@ -0,0 +1,243 @@
+"""
+V27 Rolling Window Feature Calculator
+======================================
+Computes rolling averages over 5/10/20 match windows,
+with home/away splits and trend detection.
+"""
+from __future__ import annotations
+from typing import Dict, List, Tuple
+import math
+
+
+def calc_rolling_features(
+    team_matches: List[Tuple],  # [(mst, is_home, team_goals, opp_goals, opp_id), ...]
+    before_date: int,
+    team_is_home: bool,
+) -> Dict[str, float]:
+    """Calculate rolling window features for a team before a given date."""
+    valid = [m for m in team_matches if m[0] < before_date]
+
+    defaults = {
+        "rolling5_goals_avg": 1.3, "rolling5_conceded_avg": 1.2,
+        "rolling10_goals_avg": 1.3, "rolling10_conceded_avg": 1.2,
+        "rolling20_goals_avg": 1.3, "rolling20_conceded_avg": 1.2,
+        "rolling5_clean_sheets": 0.25,
+        "venue_goals_avg": 1.3, "venue_conceded_avg": 1.2,
+        "goal_trend": 0.0,
+    }
+
+    if len(valid) < 3:
+        return defaults
+
+    result = {}
+
+    for window in [5, 10, 20]:
+        recent = valid[-window:] if len(valid) >= window else valid
+        n = len(recent)
+        g_sum = sum(m[2] for m in recent)
+        c_sum = sum(m[3] for m in recent)
+        result[f"rolling{window}_goals_avg"] = g_sum / n
+        result[f"rolling{window}_conceded_avg"] = c_sum / n
+
+    # Clean sheet rate (last 5)
+    r5 = valid[-5:] if len(valid) >= 5 else valid
+    result["rolling5_clean_sheets"] = sum(1 for m in r5 if m[3] == 0) / len(r5)
+
+    # Venue-specific (home-only or away-only)
+    venue_matches = [m for m in valid if m[1] == team_is_home]
+    if venue_matches:
+        vm = venue_matches[-10:] if len(venue_matches) >= 10 else venue_matches
+        result["venue_goals_avg"] = sum(m[2] for m in vm) / len(vm)
+        result["venue_conceded_avg"] = sum(m[3] for m in vm) / len(vm)
+    else:
+        result["venue_goals_avg"] = defaults["venue_goals_avg"]
+        result["venue_conceded_avg"] = defaults["venue_conceded_avg"]
+
+    # Goal trend: compare last 3 vs previous 3
+    if len(valid) >= 6:
+        last3 = sum(m[2] for m in valid[-3:]) / 3
+        prev3 = sum(m[2] for m in valid[-6:-3]) / 3
+        result["goal_trend"] = last3 - prev3
+    else:
+        result["goal_trend"] = 0.0
+
+    return result
+
+
+def calc_league_quality(
+    all_matches: List[Tuple],  # all FT matches in this league
+) -> Dict[str, float]:
+    """Calculate league-level quality features."""
+    defaults = {
+        "league_home_win_rate": 0.45,
+        "league_draw_rate": 0.25,
+        "league_btts_rate": 0.50,
+        "league_ou25_rate": 0.50,
+        "league_reliability_score": 0.50,
+    }
+
+    if len(all_matches) < 20:
+        return defaults
+
+    n = len(all_matches)
+    home_wins = sum(1 for m in all_matches if m[2] > m[3])
+    draws = sum(1 for m in all_matches if m[2] == m[3])
+    btts = sum(1 for m in all_matches if m[2] > 0 and m[3] > 0)
+    ou25 = sum(1 for m in all_matches if (m[2] + m[3]) > 2.5)
+
+    hw_rate = home_wins / n
+    dr_rate = draws / n
+    btts_rate = btts / n
+    ou25_rate = ou25 / n
+
+    # Reliability: leagues closer to averages are more predictable
+    predictability = 1.0 - abs(hw_rate - 0.45) - abs(dr_rate - 0.27) * 0.5
+    reliability = max(0.2, min(0.95, predictability))
+
+    return {
+        "league_home_win_rate": round(hw_rate, 4),
+        "league_draw_rate": round(dr_rate, 4),
+        "league_btts_rate": round(btts_rate, 4),
+        "league_ou25_rate": round(ou25_rate, 4),
+        "league_reliability_score": round(reliability, 4),
+    }
+
+
+def calc_time_features(
+    team_matches: List[Tuple],
+    match_mst: int,
+) -> Dict[str, float]:
+    """Calculate time-based features."""
+    from datetime import datetime
+
+    # Days since last match
+    valid = [m for m in team_matches if m[0] < match_mst]
+    if valid:
+        last_mst = valid[-1][0]
+        days_rest = (match_mst - last_mst) / 86_400_000  # ms to days
+        days_rest = min(days_rest, 60.0)  # cap at 60 days
+    else:
+        days_rest = 14.0
+
+    # Month and season flags
+    try:
+        dt = datetime.utcfromtimestamp(match_mst / 1000)
+        month = dt.month
+        is_season_start = 1.0 if month in (7, 8) else 0.0
+        is_season_end = 1.0 if month in (5, 6) else 0.0
+    except Exception:
+        month = 6
+        is_season_start = 0.0
+        is_season_end = 0.0
+
+    return {
+        "days_rest": round(days_rest, 2),
+        "match_month": month,
+        "is_season_start": is_season_start,
+        "is_season_end": is_season_end,
+    }
+
+
+def calc_advanced_h2h(
+    team_matches: List[Tuple],
+    home_id: int,
+    away_id: int,
+    before_date: int,
+) -> Dict[str, float]:
+    """Calculate advanced H2H features."""
+    defaults = {
+        "h2h_home_goals_avg": 1.3,
+        "h2h_away_goals_avg": 1.1,
+        "h2h_recent_trend": 0.0,
+        "h2h_venue_advantage": 0.0,
+    }
+
+    h2h = [m for m in team_matches if m[4] == away_id and m[0] < before_date]
+    if not h2h:
+        return defaults
+
+    recent = h2h[-10:]
+    home_goals_total = 0
+    away_goals_total = 0
+    venue_home_wins = 0
+    venue_total = 0
+
+    for mst, is_home, team_goals, opp_goals, _ in recent:
+        if is_home:
+            home_goals_total += team_goals
+            away_goals_total += opp_goals
+            venue_total += 1
+            if team_goals > opp_goals:
+                venue_home_wins += 1
+        else:
+            home_goals_total += opp_goals
+            away_goals_total += team_goals
+
+    n = len(recent)
+    result = {
+        "h2h_home_goals_avg": home_goals_total / n,
+        "h2h_away_goals_avg": away_goals_total / n,
+        "h2h_venue_advantage": venue_home_wins / venue_total if venue_total > 0 else 0.5,
+    }
+
+    # Recent trend: last 3 vs overall
+    if len(h2h) >= 4:
+        last3_pts = sum(
+            1.0 if m[2] > m[3] else (0.5 if m[2] == m[3] else 0.0)
+            for m in h2h[-3:]
+        ) / 3
+        overall_pts = sum(
+            1.0 if m[2] > m[3] else (0.5 if m[2] == m[3] else 0.0)
+            for m in h2h
+        ) / len(h2h)
+        result["h2h_recent_trend"] = round(last3_pts - overall_pts, 4)
+    else:
+        result["h2h_recent_trend"] = 0.0
+
+    return result
+
+
+def calc_strength_diff(
+    home_form: Dict[str, float],
+    away_form: Dict[str, float],
+    home_elo: Dict[str, float],
+    away_elo: Dict[str, float],
+    home_momentum: float,
+    away_momentum: float,
+    upset_potential: float,
+) -> Dict[str, float]:
+    """Calculate strength differential features."""
+    # Attack vs Defense mismatches
+    h_attack = home_form.get("goals_avg", 1.3)
+    a_defense = away_form.get("conceded_avg", 1.2)
+    a_attack = away_form.get("goals_avg", 1.3)
+    h_defense = home_form.get("conceded_avg", 1.2)
+
+    atk_def_home = h_attack - a_defense  # positive = home attack > away defense
+    atk_def_away = a_attack - h_defense
+
+    # XG diff approximation
+    xg_diff = (h_attack + a_defense) / 2 - (a_attack + h_defense) / 2
+
+    # Form × Momentum interaction
+    form_mom = (home_momentum - away_momentum) * (
+        home_form.get("scoring_rate", 0.75) - away_form.get("scoring_rate", 0.75)
+    )
+
+    # ELO-Form consistency
+    elo_diff = home_elo.get("overall", 1500) - away_elo.get("overall", 1500)
+    form_diff = h_attack - a_attack
+    elo_form_consistency = 1.0 if (elo_diff > 0 and form_diff > 0) or (elo_diff < 0 and form_diff < 0) else 0.0
+
+    # Upset × ELO gap
+    elo_gap = abs(elo_diff)
+    upset_x_elo = upset_potential * (elo_gap / 400.0)
+
+    return {
+        "attack_vs_defense_home": round(atk_def_home, 4),
+        "attack_vs_defense_away": round(atk_def_away, 4),
+        "xg_diff": round(xg_diff, 4),
+        "form_momentum_interaction": round(form_mom, 4),
+        "elo_form_consistency": elo_form_consistency,
+        "upset_x_elo_gap": round(upset_x_elo, 4),
+    }
@@ -0,0 +1,408 @@
+"""
+Sidelined Analyzer — Injury & Suspension Impact Calculator
+==========================================================
+Parses sidelined JSON from live_matches and calculates
+position-weighted missing player impact using ACTUAL player
+statistics from the database (goals, assists, starting frequency).
+
+Senior ML Engineer Principle: No magic numbers — all weights from config.
+Data Quality: Cross-reference sidelined IDs with DB for real impact.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Tuple
+
+import os
+import sys
+
+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
+
+from config.config_loader import get_config
+
+
+@dataclass
+class PlayerImpactDetail:
+    """Impact detail for a single sidelined player."""
+    player_id: str
+    player_name: str
+    position: str
+    impact_score: float
+    db_goals: int = 0
+    db_assists: int = 0
+    db_starts: int = 0
+    db_rating: float = 0.0  # Calculated from DB stats
+    is_key_player: bool = False
+    adaptation_applied: bool = False
+
+
+@dataclass
+class SidelinedImpact:
+    """Impact analysis of sidelined players for one team."""
+    total_sidelined: int = 0
+    impact_score: float = 0.0         # 0.0 - 1.0 (normalized)
+    key_position_missing: bool = False # GK or 2+ same position missing
+    key_players_missing: int = 0      # How many key players are missing
+    position_breakdown: Dict[str, int] = field(default_factory=dict)
+    player_details: List[PlayerImpactDetail] = field(default_factory=list)
+    details: List[str] = field(default_factory=list)
+
+
+class SidelinedAnalyzer:
+    """
+    Analyzes sidelined player data with DB-backed statistics.
+    
+    Impact formula per player:
+        player_impact = position_weight × db_rating_factor × adaptation_factor
+    
+    Where:
+        - position_weight: from config (GK most critical)
+        - db_rating_factor: calculated from actual goals + assists + starts (not mackolik average!)
+        - adaptation_factor: 1.0 if recent injury, discounted if team adapted (many matches missed)
+    
+    DB Query: Cross-references sidelined player IDs with match_player_events 
+    to get real goals/assists from recent matches.
+    """
+
+    def __init__(self):
+        self.config = get_config()
+        self.conn = None
+        self._load_config()
+        self._connect_db()
+
+    def _load_config(self):
+        """Load all config values once at init."""
+        cfg = self.config
+        self.position_weights = cfg.get("sidelined.position_weights", {
+            "K": 0.35, "D": 0.20, "O": 0.25, "F": 0.30
+        })
+        self.max_rating = cfg.get("sidelined.max_rating", 10)
+        self.adaptation_threshold = cfg.get("sidelined.adaptation_threshold", 10)
+        self.adaptation_discount = cfg.get("sidelined.adaptation_discount", 0.5)
+        self.goalkeeper_penalty = cfg.get("sidelined.goalkeeper_penalty", 0.15)
+        self.confidence_boost = cfg.get("sidelined.confidence_boost", 10)
+        self.max_impact = cfg.get("sidelined.max_impact", 0.85)
+        self.key_player_threshold = cfg.get("sidelined.key_player_threshold", 3)
+        self.recent_matches_lookback = cfg.get("sidelined.recent_matches_lookback", 15)
+
+    @staticmethod
+    def _safe_int(value: Any, default: int = 0) -> int:
+        try:
+            if value is None or value == "":
+                return default
+            return int(float(value))
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def _safe_float(value: Any, default: float = 0.0) -> float:
+        try:
+            if value is None or value == "":
+                return default
+            return float(value)
+        except (TypeError, ValueError):
+            return default
+
+    def _connect_db(self):
+        """Lazy DB connection following existing engine patterns."""
+        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"[SidelinedAnalyzer] DB connection failed: {e}")
+            self.conn = None
+
+    def _get_conn(self):
+        """Get or reconnect DB connection."""
+        if self.conn is None or self.conn.closed:
+            self._connect_db()
+        return self.conn
+
+    def _fetch_player_stats(self, player_ids: List[str]) -> Dict[str, Dict]:
+        """
+        Fetch real player statistics from DB for given player IDs.
+        
+        Returns dict keyed by player_id with:
+            goals: int, assists: int, starts: int, matches: int
+        """
+        conn = self._get_conn()
+        if not conn or not player_ids:
+            return {}
+
+        stats = {}
+        try:
+            cur = conn.cursor(cursor_factory=RealDictCursor)
+
+            # 1. Goals from match_player_events + Assists via assist_player_id
+            cur.execute("""
+                SELECT 
+                    sub.player_id,
+                    SUM(sub.goals) AS goals,
+                    SUM(sub.assists) AS assists
+                FROM (
+                    -- Goals: player scored
+                    SELECT mpe.player_id, 
+                           COUNT(*) AS goals, 
+                           0 AS assists
+                    FROM match_player_events mpe
+                    JOIN matches m ON mpe.match_id = m.id
+                    WHERE mpe.player_id = ANY(%s)
+                      AND mpe.event_type = 'goal'
+                      AND m.status = 'FT'
+                    GROUP BY mpe.player_id
+                    
+                    UNION ALL
+                    
+                    -- Assists: player assisted
+                    SELECT mpe.assist_player_id AS player_id,
+                           0 AS goals,
+                           COUNT(*) AS assists
+                    FROM match_player_events mpe
+                    JOIN matches m ON mpe.match_id = m.id
+                    WHERE mpe.assist_player_id = ANY(%s)
+                      AND mpe.event_type = 'goal'
+                      AND m.status = 'FT'
+                    GROUP BY mpe.assist_player_id
+                ) sub
+                GROUP BY sub.player_id
+            """, (player_ids, player_ids))
+
+            for row in cur.fetchall():
+                pid = row["player_id"]
+                stats[pid] = {
+                    "goals": row["goals"] or 0,
+                    "assists": row["assists"] or 0,
+                    "starts": 0,
+                    "matches": 0
+                }
+
+            # 2. Starting frequency from match_player_participation
+            cur.execute("""
+                SELECT 
+                    mpp.player_id,
+                    COUNT(*) AS total_matches,
+                    COUNT(*) FILTER (WHERE mpp.is_starting = true) AS starts
+                FROM match_player_participation mpp
+                JOIN matches m ON mpp.match_id = m.id
+                WHERE mpp.player_id = ANY(%s)
+                  AND m.status = 'FT'
+                GROUP BY mpp.player_id
+            """, (player_ids,))
+
+            for row in cur.fetchall():
+                pid = row["player_id"]
+                if pid not in stats:
+                    stats[pid] = {"goals": 0, "assists": 0, "starts": 0, "matches": 0}
+                stats[pid]["starts"] = row["starts"] or 0
+                stats[pid]["matches"] = row["total_matches"] or 0
+
+            cur.close()
+        except Exception as e:
+            print(f"[SidelinedAnalyzer] DB query error: {e}")
+            try:
+                conn.rollback()
+            except Exception:
+                pass
+
+        return stats
+
+    def _calculate_db_rating(self, db_stats: Dict, position: str) -> float:
+        """
+        Calculate player rating from DB statistics.
+        
+        Rating is 0.0 - 1.0, where 1.0 = absolute key player.
+        
+        Factors:
+            - Goals (weighted by position: Forwards value more, Defenders less)
+            - Assists 
+            - Starting frequency (regulars > squad players)
+        """
+        def _to_float(value: Any, default: float = 0.0) -> float:
+            try:
+                return float(value)
+            except (TypeError, ValueError):
+                return default
+
+        goals = _to_float(db_stats.get("goals", 0))
+        assists = _to_float(db_stats.get("assists", 0))
+        starts = _to_float(db_stats.get("starts", 0))
+        matches = _to_float(db_stats.get("matches", 0))
+
+        # Goal contribution weight by position 
+        # Forwards: goals matter most
+        # Midfielders: balanced
+        # Defenders: starts matter more than goals
+        # Goalkeeper: starts are everything
+        goal_weight = {"F": 0.5, "O": 0.35, "D": 0.15, "K": 0.05}.get(position, 0.25)
+        assist_weight = {"F": 0.2, "O": 0.3, "D": 0.15, "K": 0.0}.get(position, 0.15)
+        start_weight = {"F": 0.3, "O": 0.35, "D": 0.7, "K": 0.95}.get(position, 0.5)
+
+        # Normalize each component to 0-1
+        # Goals: 5+ goals in recent matches = max
+        goal_factor = min(goals / 5.0, 1.0) if goals > 0 else 0.0
+        # Assists: 4+ assists = max
+        assist_factor = min(assists / 4.0, 1.0) if assists > 0 else 0.0
+        # Starts: 80%+ start rate = max regular
+        start_rate = starts / max(matches, 1)
+        start_factor = min(start_rate / 0.8, 1.0)
+
+        rating = (goal_factor * goal_weight + 
+                  assist_factor * assist_weight + 
+                  start_factor * start_weight)
+
+        return round(min(rating, 1.0), 4)
+
+    def analyze(self, team_data: Optional[Dict[str, Any]]) -> SidelinedImpact:
+        """
+        Analyze sidelined data for a single team using DB-backed stats.
+        
+        Args:
+            team_data: dict with 'players' list and 'totalSidelined' count.
+        
+        Returns:
+            SidelinedImpact with calculated impact score and breakdown.
+        """
+        if not team_data or not isinstance(team_data, dict):
+            return SidelinedImpact()
+
+        players = team_data.get("players", [])
+        if not players:
+            return SidelinedImpact(
+                total_sidelined=team_data.get("totalSidelined", 0)
+            )
+
+        # Collect player IDs for batch DB query
+        player_ids = [p.get("playerId", "") for p in players if p.get("playerId")]
+
+        # Batch fetch DB stats (single query, not N+1)
+        db_stats = self._fetch_player_stats(player_ids) if player_ids else {}
+
+        total_impact = 0.0
+        position_counts: Dict[str, int] = {}
+        player_details: List[PlayerImpactDetail] = []
+        details: List[str] = []
+        has_gk_missing = False
+        key_players_count = 0
+
+        for player in players:
+            if not isinstance(player, dict):
+                continue
+
+            pos = player.get("positionShort", "O")
+            name = player.get("playerName", "Unknown")
+            pid = player.get("playerId", "")
+            matches_missed = self._safe_int(player.get("matchesMissed", 0), 0)
+            player_type = player.get("type", "other")
+            mackolik_avg = self._safe_float(player.get("average", 0), 0.0)
+
+            position_counts[pos] = position_counts.get(pos, 0) + 1
+
+            if pos == "K":
+                has_gk_missing = True
+
+            # === Rating: DB first, mackolik fallback ===
+            p_db_stats = db_stats.get(pid, {})
+            
+            if p_db_stats:
+                # Use real DB stats
+                db_rating = self._calculate_db_rating(p_db_stats, pos)
+            else:
+                # Fallback to mackolik average (normalized)
+                db_rating = min(mackolik_avg / self.max_rating, 1.0) if self.max_rating > 0 else 0.3
+                db_rating = max(db_rating, 0.15)  # Minimum floor
+
+            # Key player check
+            is_key = db_rating >= 0.5 or (
+                self._safe_int(p_db_stats.get("goals", 0), 0) >= self.key_player_threshold
+            )
+            if is_key:
+                key_players_count += 1
+
+            # === Impact Calculation ===
+            pos_weight = self.position_weights.get(pos, 0.20)
+
+            # Rating factor: higher rated = bigger loss
+            rating_factor = max(db_rating, 0.15)  # Even unknown players have minimum impact
+
+            # Adaptation: team has coped if player missed many matches
+            adapted = matches_missed >= self.adaptation_threshold
+            adapt_factor = self.adaptation_discount if adapted else 1.0
+
+            # Type factor
+            type_factor = 1.0 if player_type == "injury" else 0.8
+
+            player_impact = pos_weight * rating_factor * adapt_factor * type_factor
+            total_impact += player_impact
+
+            detail = PlayerImpactDetail(
+                player_id=pid,
+                player_name=name,
+                position=pos,
+                impact_score=round(player_impact, 4),
+                db_goals=p_db_stats.get("goals", 0),
+                db_assists=p_db_stats.get("assists", 0),
+                db_starts=p_db_stats.get("starts", 0),
+                db_rating=db_rating,
+                is_key_player=is_key,
+                adaptation_applied=adapted
+            )
+            player_details.append(detail)
+
+            db_info = f"G:{detail.db_goals} A:{detail.db_assists} S:{detail.db_starts}" if p_db_stats else "no DB data"
+            details.append(
+                f"{name} ({pos}, db_rating:{db_rating:.2f}, {db_info}) → impact:{player_impact:.3f}"
+                + (" ⭐ KEY" if is_key else "")
+                + (f" [adapted, {matches_missed} missed]" if adapted else "")
+            )
+
+        # GK penalty bonus
+        if has_gk_missing:
+            total_impact += self.goalkeeper_penalty
+
+        key_position_missing = has_gk_missing or any(v >= 2 for v in position_counts.values())
+
+        # Normalize to 0-1 range
+        normalization_cap = 1.5
+        normalized_impact = min(total_impact / normalization_cap, self.max_impact)
+
+        return SidelinedImpact(
+            total_sidelined=len(players),
+            impact_score=round(normalized_impact, 4),
+            key_position_missing=key_position_missing,
+            key_players_missing=key_players_count,
+            position_breakdown=position_counts,
+            player_details=player_details,
+            details=details
+        )
+
+    def analyze_match(self, sidelined_json: Optional[Dict[str, Any]]) -> Tuple[SidelinedImpact, SidelinedImpact]:
+        """
+        Analyze sidelined data for both teams.
+        
+        Returns:
+            (home_impact, away_impact)
+        """
+        if not sidelined_json or not isinstance(sidelined_json, dict):
+            return SidelinedImpact(), SidelinedImpact()
+
+        home_impact = self.analyze(sidelined_json.get("homeTeam"))
+        away_impact = self.analyze(sidelined_json.get("awayTeam"))
+        return home_impact, away_impact
+
+
+# Singleton
+_analyzer: Optional[SidelinedAnalyzer] = None
+
+
+def get_sidelined_analyzer() -> SidelinedAnalyzer:
+    global _analyzer
+    if _analyzer is None:
+        _analyzer = SidelinedAnalyzer()
+    return _analyzer
@@ -0,0 +1,357 @@
+"""
+Smart Bet Recommender
+=====================
+
+Skor tahminine göre akıllı bahis önerileri yapan sistem.
+
+Örnek: Beşiktaş-Galatasaray için model 3-1 tahmin ediyor
+→ DÜŞÜK RİSK: 1.5 Üst (yüksek ihtimal tutar)
+→ ORTA RİSK: MS 1 + 2.5 Üst (orta ihtimal)
+→ YÜKSEK RİSK: 3.5 Üst veya skor 3-1 (düşük ihtimal, yüksek kazanç)
+
+Ayrıca kombinasyonlar:
+- MS 1 + 1.5 Üst
+- MS 1 + KG Var
+- Her iki takım skor > 0.5 (her takım en az 1 gol atar)
+"""
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+from enum import Enum
+
+
+class RiskLevel(Enum):
+    LOW = "LOW"          # Yüksek olasılık, düşük oran (güvenli)
+    MEDIUM = "MEDIUM"    # Orta olasılık, orta oran
+    HIGH = "HIGH"        # Düşük olasılık, yüksek kazanç
+    EXTREME = "EXTREME"  # Çok düşük olasılık, çok yüksek kazanç
+
+
+@dataclass
+class BetRecommendation:
+    """Tek bir bahis önerisi"""
+    market: str           # Piyasa adı (örn: "MS 1", "2.5 Üst")
+    pick: str             # Seçim (örn: "1", "OVER", "YES")
+    odds: float           # Oran
+    probability: float    # Model olasılığı (0-1)
+    confidence: float     # Güven seviyesi (0-100)
+    risk_level: RiskLevel
+    
+    def to_dict(self) -> dict:
+        return {
+            "market": self.market,
+            "pick": self.pick,
+            "odds": self.odds,
+            "probability": round(self.probability * 100, 1),
+            "confidence": round(self.confidence, 1),
+            "risk_level": self.risk_level.value
+        }
+
+
+@dataclass
+class MatchPredictionSet:
+    """Bir maç için tüm tahmin seti"""
+    match_name: str
+    predicted_score: Tuple[int, int]  # (home, away)
+    home_win_prob: float
+    draw_prob: float
+    away_win_prob: float
+    over_15_prob: float
+    over_25_prob: float
+    over_35_prob: float
+    btts_yes_prob: float
+    
+    # Öneriler
+    low_risk_bets: List[BetRecommendation]
+    medium_risk_bets: List[BetRecommendation]
+    high_risk_bets: List[BetRecommendation]
+    extreme_risk_bets: List[BetRecommendation]
+    
+    def to_dict(self) -> dict:
+        return {
+            "match_name": self.match_name,
+            "predicted_score": f"{self.predicted_score[0]}-{self.predicted_score[1]}",
+            "probs": {
+                "home_win": round(self.home_win_prob * 100, 1),
+                "draw": round(self.draw_prob * 100, 1),
+                "away_win": round(self.away_win_prob * 100, 1),
+                "over_15": round(self.over_15_prob * 100, 1),
+                "over_25": round(self.over_25_prob * 100, 1),
+                "over_35": round(self.over_35_prob * 100, 1),
+                "btts": round(self.btts_yes_prob * 100, 1)
+            },
+            "low_risk": [b.to_dict() for b in self.low_risk_bets],
+            "medium_risk": [b.to_dict() for b in self.medium_risk_bets],
+            "high_risk": [b.to_dict() for b in self.high_risk_bets],
+            "extreme_risk": [b.to_dict() for b in self.extreme_risk_bets]
+        }
+
+
+class SmartBetRecommender:
+    """
+    Akıllı Bahis Öneri Sistemi
+    
+    Skor tahminine göre farklı risk seviyelerinde bahisler önerir.
+    
+    Mantık:
+    1. DÜŞÜK RİSK: Yüksek olasılıklı (>70%), düşük oranlı bahisler
+       - 1.5 Üst
+       - Double Chance
+       - Favori takım gol atar
+    
+    2. ORTA RİSK: Orta olasılıklı (50-70%), orta oranlı bahisler
+       - MS favori
+       - 2.5 Üst
+       - KG Var/Var
+    
+    3. YÜKSEK RİSK: Düşük olasılıklı (30-50%), yüksek oranlı bahisler
+       - 3.5 Üst
+       - Skor tahmini
+       - Handikap
+    
+    4. EXTREME RİSK: Çok düşük olasılıklı (<30%), çok yüksek oranlı
+       - Tam skor
+       - Uzunluklu kombinasyonlar
+    """
+    
+    # Olasılık eşikleri
+    PROB_LOW_RISK = 0.70      # > %70 olasılık
+    PROB_MEDIUM_RISK = 0.50   # %50-70 olasılık
+    PROB_HIGH_RISK = 0.30     # %30-50 olasılık
+    # < %30 = EXTREME
+    
+    def __init__(self):
+        pass
+    
+    def _determine_risk(self, probability: float) -> RiskLevel:
+        """Olasılığa göre risk seviyesi belirle"""
+        if probability >= self.PROB_LOW_RISK:
+            return RiskLevel.LOW
+        elif probability >= self.PROB_MEDIUM_RISK:
+            return RiskLevel.MEDIUM
+        elif probability >= self.PROB_HIGH_RISK:
+            return RiskLevel.HIGH
+        else:
+            return RiskLevel.EXTREME
+    
+    def _get_favorite(self, home_prob: float, draw_prob: float, away_prob: float) -> Tuple[str, float]:
+        """Favori sonucu ve olasılığını döndür"""
+        if home_prob >= draw_prob and home_prob >= away_prob:
+            return "1", home_prob
+        elif away_prob >= home_prob and away_prob >= draw_prob:
+            return "2", away_prob
+        else:
+            return "X", draw_prob
+    
+    def _calculate_expected_goals(self, predicted_score: Tuple[int, int]) -> float:
+        """Tahmin edilen skora göre beklenen gol sayısı"""
+        return predicted_score[0] + predicted_score[1]
+    
+    def recommend(
+        self,
+        match_name: str,
+        predicted_score: Tuple[int, int],
+        probs: Dict[str, float],
+        odds: Dict[str, float]
+    ) -> MatchPredictionSet:
+        """
+        Maç için tüm bahis önerilerini oluştur.
+        
+        Args:
+            match_name: Maç adı
+            predicted_score: (home_goals, away_goals)
+            probs: {"home_win": 0.55, "draw": 0.25, "away_win": 0.20,
+                    "over_15": 0.85, "over_25": 0.65, "over_35": 0.35,
+                    "btts_yes": 0.55}
+            odds: {"1": 1.80, "X": 3.50, "2": 4.20,
+                   "ou15_o": 1.25, "ou15_u": 3.80,
+                   "ou25_o": 1.90, "ou25_u": 1.85,
+                   "ou35_o": 3.20, "ou35_u": 1.30,
+                   "btts_y": 1.75, "btts_n": 2.00}
+        
+        Returns:
+            MatchPredictionSet with all recommendations
+        """
+        home_prob = probs.get("home_win", 0.33)
+        draw_prob = probs.get("draw", 0.33)
+        away_prob = probs.get("away_win", 0.33)
+        over_15_prob = probs.get("over_15", 0.70)
+        over_25_prob = probs.get("over_25", 0.50)
+        over_35_prob = probs.get("over_35", 0.30)
+        btts_prob = probs.get("btts_yes", 0.50)
+        
+        # Beklenen goller
+        expected_goals = self._calculate_expected_goals(predicted_score)
+        
+        # Favori
+        favorite, favorite_prob = self._get_favorite(home_prob, draw_prob, away_prob)
+        
+        # Önerileri oluştur
+        low_risk = []
+        medium_risk = []
+        high_risk = []
+        extreme_risk = []
+        
+        # ========== DÜŞÜK RİSK ÖNERİLERİ ==========
+        # 1.5 Üst (en güvenli)
+        if over_15_prob >= self.PROB_LOW_RISK:
+            low_risk.append(BetRecommendation(
+                market="1.5 Üst/Alt",
+                pick="OVER",
+                odds=odds.get("ou15_o", 1.25),
+                probability=over_15_prob,
+                confidence=over_15_prob * 100,
+                risk_level=RiskLevel.LOW
+            ))
+        
+        # Double Chance
+        if home_prob > away_prob:
+            dc_prob = home_prob + draw_prob
+            if dc_prob >= self.PROB_LOW_RISK:
+                low_risk.append(BetRecommendation(
+                    market="Double Chance",
+                    pick="1X",
+                    odds=odds.get("dc_1x", 1.30),
+                    probability=dc_prob,
+                    confidence=dc_prob * 100,
+                    risk_level=RiskLevel.LOW
+                ))
+        elif away_prob > home_prob:
+            dc_prob = away_prob + draw_prob
+            if dc_prob >= self.PROB_LOW_RISK:
+                low_risk.append(BetRecommendation(
+                    market="Double Chance",
+                    pick="X2",
+                    odds=odds.get("dc_x2", 1.30),
+                    probability=dc_prob,
+                    confidence=dc_prob * 100,
+                    risk_level=RiskLevel.LOW
+                ))
+        
+        # ========== ORTA RİSK ÖNERİLERİ ==========
+        # MS Favori
+        if self.PROB_MEDIUM_RISK <= favorite_prob < self.PROB_LOW_RISK:
+            medium_risk.append(BetRecommendation(
+                market="Maç Sonucu",
+                pick=favorite,
+                odds=odds.get(favorite, 2.00),
+                probability=favorite_prob,
+                confidence=favorite_prob * 100,
+                risk_level=RiskLevel.MEDIUM
+            ))
+        
+        # 2.5 Üst
+        if self.PROB_MEDIUM_RISK <= over_25_prob < self.PROB_LOW_RISK:
+            medium_risk.append(BetRecommendation(
+                market="2.5 Üst/Alt",
+                pick="OVER",
+                odds=odds.get("ou25_o", 1.90),
+                probability=over_25_prob,
+                confidence=over_25_prob * 100,
+                risk_level=RiskLevel.MEDIUM
+            ))
+        
+        # KG Var
+        if self.PROB_MEDIUM_RISK <= btts_prob < self.PROB_LOW_RISK:
+            medium_risk.append(BetRecommendation(
+                market="Karşılıklı Gol",
+                pick="YES",
+                odds=odds.get("btts_y", 1.75),
+                probability=btts_prob,
+                confidence=btts_prob * 100,
+                risk_level=RiskLevel.MEDIUM
+            ))
+        
+        # MS + 2.5 Üst kombinasyonu
+        if favorite_prob >= 0.45 and over_25_prob >= 0.50:
+            combo_prob = favorite_prob * over_25_prob  # Basit çarpım
+            combo_odds = odds.get(favorite, 2.00) * odds.get("ou25_o", 1.90)
+            if combo_prob >= 0.30:  # En az %30 olasılık
+                medium_risk.append(BetRecommendation(
+                    market=f"MS {favorite} + 2.5 Üst",
+                    pick=f"{favorite} & OVER",
+                    odds=combo_odds,
+                    probability=combo_prob,
+                    confidence=combo_prob * 100,
+                    risk_level=RiskLevel.MEDIUM
+                ))
+        
+        # ========== YÜKSEK RİSK ÖNERİLERİ ==========
+        # 3.5 Üst
+        if self.PROB_HIGH_RISK <= over_35_prob < self.PROB_MEDIUM_RISK:
+            high_risk.append(BetRecommendation(
+                market="3.5 Üst/Alt",
+                pick="OVER",
+                odds=odds.get("ou35_o", 3.20),
+                probability=over_35_prob,
+                confidence=over_35_prob * 100,
+                risk_level=RiskLevel.HIGH
+            ))
+        
+        # Skor tahmini (yüksek skorlu maçlar için)
+        if expected_goals >= 3.5:
+            score_str = f"{predicted_score[0]}-{predicted_score[1]}"
+            # Skor olasılığı tahmini (basit model)
+            score_prob = 0.15 if expected_goals <= 4 else 0.10
+            high_risk.append(BetRecommendation(
+                market="Tam Skor",
+                pick=score_str,
+                odds=8.0,  # Tahmini oran
+                probability=score_prob,
+                confidence=score_prob * 100,
+                risk_level=RiskLevel.HIGH
+            ))
+        
+        # MS + 3.5 Üst
+        if favorite_prob >= 0.40 and over_35_prob >= 0.30:
+            combo_prob = favorite_prob * over_35_prob
+            combo_odds = odds.get(favorite, 2.00) * odds.get("ou35_o", 3.20)
+            high_risk.append(BetRecommendation(
+                market=f"MS {favorite} + 3.5 Üst",
+                pick=f"{favorite} & OVER",
+                odds=combo_odds,
+                probability=combo_prob,
+                confidence=combo_prob * 100,
+                risk_level=RiskLevel.HIGH
+            ))
+        
+        # ========== EXTREME RİSK ÖNERİLERİ ==========
+        # Uzun kombinasyonlar
+        if favorite_prob >= 0.50 and btts_prob >= 0.50 and over_25_prob >= 0.60:
+            combo_prob = favorite_prob * btts_prob * over_25_prob
+            combo_odds = odds.get(favorite, 2.00) * odds.get("btts_y", 1.75) * odds.get("ou25_o", 1.90)
+            if combo_prob >= 0.15:  # En az %15 olasılık
+                extreme_risk.append(BetRecommendation(
+                    market=f"MS {favorite} + KG Var + 2.5 Üst",
+                    pick=f"{favorite} & BTTS & OVER",
+                    odds=combo_odds,
+                    probability=combo_prob,
+                    confidence=combo_prob * 100,
+                    risk_level=RiskLevel.EXTREME
+                ))
+        
+        return MatchPredictionSet(
+            match_name=match_name,
+            predicted_score=predicted_score,
+            home_win_prob=home_prob,
+            draw_prob=draw_prob,
+            away_win_prob=away_prob,
+            over_15_prob=over_15_prob,
+            over_25_prob=over_25_prob,
+            over_35_prob=over_35_prob,
+            btts_yes_prob=btts_prob,
+            low_risk_bets=low_risk,
+            medium_risk_bets=medium_risk,
+            high_risk_bets=high_risk,
+            extreme_risk_bets=extreme_risk
+        )
+
+
+# Singleton
+_recommender = None
+
+def get_smart_bet_recommender() -> SmartBetRecommender:
+    global _recommender
+    if _recommender is None:
+        _recommender = SmartBetRecommender()
+    return _recommender
@@ -0,0 +1,582 @@
+"""
+Squad Analysis Engine - V9 Feature
+Kadro ve oyuncu bazlı analiz.
+
+Analiz Edilen Metrikler:
+- İlk 11 kalitesi (golcü formu, key player)
+- Yedek gücü
+- Eksik oyuncu etkisi
+- Pozisyon bazlı güç
+- Takım içi golcü dağılımı
+"""
+
+import os
+from typing import Dict, Optional, List, Tuple
+from dataclasses import dataclass, field
+from datetime import datetime
+from collections import defaultdict
+
+try:
+    import psycopg2
+    from psycopg2.extras import RealDictCursor
+except ImportError:
+    psycopg2 = None
+
+
+@dataclass
+class PlayerForm:
+    """Oyuncu form bilgisi"""
+    player_id: str
+    player_name: str
+    goals_last_5: int = 0
+    assists_last_5: int = 0
+    minutes_last_5: int = 0
+    cards_last_5: int = 0
+    is_key_player: bool = False  # Golcü veya sık oynayan
+    
+
+@dataclass
+class SquadAnalysis:
+    """Takım kadro analizi"""
+    team_id: str
+    team_name: str = ""
+    
+    # İlk 11 bilgisi
+    starting_count: int = 0
+    sub_count: int = 0
+    total_squad: int = 0
+    
+    # Pozisyon dağılımı
+    goalkeeper_count: int = 0
+    defender_count: int = 0
+    midfielder_count: int = 0
+    forward_count: int = 0
+    
+    # Form metrikleri
+    total_goals_last_5: int = 0  # Kadrodaki oyuncuların son 5 maçtaki golleri
+    total_assists_last_5: int = 0
+    key_players_count: int = 0  # Golcü sayısı
+    key_player_missing: int = 0  # Eksik golcü
+    
+    # Kalite metrikleri
+    avg_minutes_per_player: float = 0.0  # Ortalama oynama süresi
+    squad_experience: float = 0.0  # 0-1, takımla oynama deneyimi
+    rotation_rate: float = 0.0  # Kadro rotasyonu oranı
+
+
+@dataclass
+class SquadFeatures:
+    """Model için kadro feature'ları"""
+    # Home team features
+    home_starting_11: int = 11
+    home_sub_count: int = 7
+    home_total_squad: int = 18
+    home_goalkeepers: int = 1
+    home_defenders: int = 4
+    home_midfielders: int = 4
+    home_forwards: int = 2
+    home_goals_last_5: int = 0
+    home_assists_last_5: int = 0
+    home_key_players: int = 0
+    home_squad_experience: float = 0.5
+    
+    # Away team features
+    away_starting_11: int = 11
+    away_sub_count: int = 7
+    away_total_squad: int = 18
+    away_goalkeepers: int = 1
+    away_defenders: int = 4
+    away_midfielders: int = 4
+    away_forwards: int = 2
+    away_goals_last_5: int = 0
+    away_assists_last_5: int = 0
+    away_key_players: int = 0
+    away_squad_experience: float = 0.5
+    
+    # Comparison features
+    squad_strength_diff: float = 0.0  # + = home stronger
+    goals_form_diff: float = 0.0
+    key_players_diff: int = 0
+    
+    def to_dict(self) -> Dict[str, float]:
+        return {
+            # Home
+            'home_starting_11': float(self.home_starting_11),
+            'home_sub_count': float(self.home_sub_count),
+            'home_total_squad': float(self.home_total_squad),
+            'home_goalkeepers': float(self.home_goalkeepers),
+            'home_defenders': float(self.home_defenders),
+            'home_midfielders': float(self.home_midfielders),
+            'home_forwards': float(self.home_forwards),
+            'home_goals_last_5': float(self.home_goals_last_5),
+            'home_assists_last_5': float(self.home_assists_last_5),
+            'home_key_players': float(self.home_key_players),
+            'home_squad_experience': self.home_squad_experience,
+            # Away
+            'away_starting_11': float(self.away_starting_11),
+            'away_sub_count': float(self.away_sub_count),
+            'away_total_squad': float(self.away_total_squad),
+            'away_goalkeepers': float(self.away_goalkeepers),
+            'away_defenders': float(self.away_defenders),
+            'away_midfielders': float(self.away_midfielders),
+            'away_forwards': float(self.away_forwards),
+            'away_goals_last_5': float(self.away_goals_last_5),
+            'away_assists_last_5': float(self.away_assists_last_5),
+            'away_key_players': float(self.away_key_players),
+            'away_squad_experience': self.away_squad_experience,
+            # Diffs
+            'squad_strength_diff': self.squad_strength_diff,
+            'goals_form_diff': self.goals_form_diff,
+            'key_players_diff': float(self.key_players_diff),
+        }
+
+
+class SquadAnalysisEngine:
+    """
+    Kadro ve oyuncu analiz motoru.
+    
+    Beşiktaş-Galatasaray maçı için:
+    - İlk 11'deki oyuncuların son 5 maçtaki gol/asist
+    - Key player tespiti (çok gol atan oyuncular)
+    - Pozisyon dağılımı (4-3-3, 4-4-2 vb.)
+    - Yedek kalitesi
+    hesaplar.
+    """
+    
+    # Pozisyon mapping
+    POSITION_MAP = {
+        'goalkeeper': 'GK',
+        'gk': 'GK',
+        'kaleci': 'GK',
+        'defender': 'DEF',
+        'def': 'DEF',
+        'defans': 'DEF',
+        'savunma': 'DEF',
+        'midfielder': 'MID',
+        'mid': 'MID',
+        'orta saha': 'MID',
+        'forward': 'FWD',
+        'fwd': 'FWD',
+        'forvet': 'FWD',
+        'striker': 'FWD',
+    }
+    
+    def __init__(self):
+        self.conn = None
+        self._player_form_cache: Dict[str, PlayerForm] = {}
+    
+    def _connect_db(self):
+        if psycopg2 is None:
+            return None
+        try:
+            from data.db import get_clean_dsn
+            self.conn = psycopg2.connect(get_clean_dsn())
+            return self.conn
+        except Exception as e:
+            print(f"[SquadEngine] DB connection failed: {e}")
+            return None
+    
+    def get_conn(self):
+        if self.conn is None or self.conn.closed:
+            self._connect_db()
+        return self.conn
+    
+    def _normalize_position(self, position: Optional[str]) -> str:
+        """Pozisyonu normalize et"""
+        if not position:
+            return 'UNK'
+        
+        pos_lower = position.lower().strip()
+        for key, val in self.POSITION_MAP.items():
+            if key in pos_lower:
+                return val
+        return 'UNK'
+    
+    def get_player_form(self, player_id: str, before_date_ms: int = None) -> PlayerForm:
+        """Oyuncunun son 5 maçtaki formunu hesapla"""
+        
+        if player_id in self._player_form_cache:
+            return self._player_form_cache[player_id]
+        
+        form = PlayerForm(player_id=player_id, player_name="")
+        
+        conn = self.get_conn()
+        if conn is None:
+            return form
+        
+        try:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                # Oyuncu adını al
+                cur.execute("SELECT name FROM players WHERE id = %s", (player_id,))
+                player_row = cur.fetchone()
+                if player_row:
+                    form.player_name = player_row['name']
+                
+                # Son 5 maçtaki gol ve asist
+                cur.execute("""
+                    SELECT 
+                        COUNT(*) FILTER (WHERE event_type = 'goal' AND event_subtype NOT ILIKE '%%penaltı kaçırma%%') as goals,
+                        COUNT(*) FILTER (WHERE event_type = 'goal' AND assist_player_id IS NOT NULL) as assists_given
+                    FROM match_player_events
+                    WHERE player_id = %s
+                      AND match_id IN (
+                          SELECT match_id FROM match_player_participation 
+                          WHERE player_id = %s 
+                          ORDER BY match_id DESC LIMIT 5
+                      )
+                """, (player_id, player_id))
+                
+                stats = cur.fetchone()
+                if stats:
+                    form.goals_last_5 = stats['goals'] or 0
+                    
+                # Asist hesapla (assist_player_id olarak geçen)
+                cur.execute("""
+                    SELECT COUNT(*) as assists
+                    FROM match_player_events
+                    WHERE assist_player_id = %s
+                      AND match_id IN (
+                          SELECT match_id FROM match_player_participation 
+                          WHERE player_id = %s 
+                          ORDER BY match_id DESC LIMIT 5
+                      )
+                """, (player_id, player_id))
+                
+                assist_row = cur.fetchone()
+                if assist_row:
+                    form.assists_last_5 = assist_row['assists'] or 0
+                
+                # Kart sayısı
+                cur.execute("""
+                    SELECT COUNT(*) as cards
+                    FROM match_player_events
+                    WHERE player_id = %s AND event_type = 'card'
+                      AND match_id IN (
+                          SELECT match_id FROM match_player_participation 
+                          WHERE player_id = %s 
+                          ORDER BY match_id DESC LIMIT 5
+                      )
+                """, (player_id, player_id))
+                
+                card_row = cur.fetchone()
+                if card_row:
+                    form.cards_last_5 = card_row['cards'] or 0
+                
+                # Key player mi? (Son 10 maçta 3+ gol)
+                cur.execute("""
+                    SELECT COUNT(*) as total_goals
+                    FROM match_player_events
+                    WHERE player_id = %s 
+                      AND event_type = 'goal'
+                      AND event_subtype NOT ILIKE '%%penaltı kaçırma%%'
+                """, (player_id,))
+                
+                total_row = cur.fetchone()
+                form.is_key_player = (total_row['total_goals'] or 0) >= 3
+                
+            self._player_form_cache[player_id] = form
+            return form
+            
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            print(f"[SquadEngine] Error getting player form: {e}")
+            return form
+    
+    def analyze_squad(self, match_id: str, team_id: str) -> SquadAnalysis:
+        """Takımın maç kadrosunu analiz et"""
+        
+        analysis = SquadAnalysis(team_id=team_id)
+        
+        conn = self.get_conn()
+        if conn is None:
+            return analysis
+        
+        try:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                # Takım adını al
+                cur.execute("SELECT name FROM teams WHERE id = %s", (team_id,))
+                team_row = cur.fetchone()
+                if team_row:
+                    analysis.team_name = team_row['name']
+                
+                # Maç kadrosunu al
+                cur.execute("""
+                    SELECT player_id, position, is_starting
+                    FROM match_player_participation
+                    WHERE match_id = %s AND team_id = %s
+                """, (match_id, team_id))
+                
+                players = cur.fetchall()
+                
+                for p in players:
+                    if p['is_starting']:
+                        analysis.starting_count += 1
+                    else:
+                        analysis.sub_count += 1
+                    
+                    pos = self._normalize_position(p['position'])
+                    if pos == 'GK':
+                        analysis.goalkeeper_count += 1
+                    elif pos == 'DEF':
+                        analysis.defender_count += 1
+                    elif pos == 'MID':
+                        analysis.midfielder_count += 1
+                    elif pos == 'FWD':
+                        analysis.forward_count += 1
+                    
+                    # İlk 11'in formunu topluca hesapla
+                    if p['is_starting']:
+                        form = self.get_player_form(p['player_id'])
+                        analysis.total_goals_last_5 += form.goals_last_5
+                        analysis.total_assists_last_5 += form.assists_last_5
+                        if form.is_key_player:
+                            analysis.key_players_count += 1
+                
+                analysis.total_squad = analysis.starting_count + analysis.sub_count
+                
+                # Takım deneyimi (bu takımla kaç maç oynamışlar)
+                if analysis.starting_count > 0:
+                    cur.execute("""
+                        SELECT AVG(match_count) as avg_exp
+                        FROM (
+                            SELECT player_id, COUNT(*) as match_count
+                            FROM match_player_participation
+                            WHERE team_id = %s AND is_starting = true
+                            GROUP BY player_id
+                        ) sub
+                    """, (team_id,))
+                    
+                    exp_row = cur.fetchone()
+                    if exp_row and exp_row['avg_exp']:
+                        # Normalize: 50+ maç = 1.0
+                        analysis.squad_experience = min(exp_row['avg_exp'] / 50, 1.0)
+            
+            return analysis
+            
+        except Exception as e:
+            print(f"[SquadEngine] Error analyzing squad: {e}")
+            return analysis
+
+    def analyze_squad_from_list(self, player_ids: List[str], team_id: str) -> SquadAnalysis:
+        """
+        Memory'deki oyuncu listesinden kadro analizi yap.
+        DB'de olmayan canlı maçlar için kullanılır.
+        """
+        analysis = SquadAnalysis(team_id=team_id)
+        # Varsayılan: İlk 11 oyuncu (listede genellikle ilk 11 verilir)
+        
+        # Eğer liste boşsa
+        if not player_ids:
+             return analysis
+
+        # Varsayımlar: Mackolik API'den gelen liste sıralıdır. 
+        # İlk 11 genellikle as kadrodur. Ancak burada sadece 'starting' oyuncuları alıyoruz varsayalım.
+        # User calling uses explicit starting 11 list.
+        
+        analysis.starting_count = len(player_ids)
+        analysis.total_squad = len(player_ids) # Subs unknown usually unless separate list
+        
+        # Position tahmini zor, default dağıt? Veya oyuncu detayına git?
+        # Hız için: Oyuncu ID'sinden DB'ye bakıp pozisyon öğrenmeye çalışabiliriz.
+        
+        conn = self.get_conn()
+        if conn is None:
+             return analysis
+
+        try:
+             with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                 # Calculate stats for these specific players
+                 for pid in player_ids:
+                      # Get Form
+                      form = self.get_player_form(pid)
+                      analysis.total_goals_last_5 += form.goals_last_5
+                      analysis.total_assists_last_5 += form.assists_last_5
+                      if form.is_key_player:
+                           analysis.key_players_count += 1
+                           
+                      # Get Position/Exp history attempt
+                      cur.execute("""
+                          SELECT position, COUNT(*) as match_count 
+                          FROM match_player_participation
+                          WHERE player_id = %s AND team_id = %s
+                          GROUP BY position
+                          ORDER BY match_count DESC LIMIT 1
+                      """, (pid, team_id))
+                      row = cur.fetchone()
+                      
+                      if row:
+                           pos = self._normalize_position(row.get('position', 'UNK'))
+                           if pos == 'GK': analysis.goalkeeper_count += 1
+                           elif pos == 'DEF': analysis.defender_count += 1
+                           elif pos == 'MID': analysis.midfielder_count += 1
+                           elif pos == 'FWD': analysis.forward_count += 1
+                           
+                           # Experience contribution
+                           exp = min(row['match_count'] / 50.0, 1.0)
+                           analysis.squad_experience += exp
+                           
+                 # Average experience
+                 if analysis.starting_count > 0:
+                      analysis.squad_experience /= analysis.starting_count
+                      
+        except Exception as e:
+             print(f"[SquadEngine] Live analyze error: {e}")
+
+        return analysis
+    
+    def get_features(
+        self, 
+        match_id: str, 
+        home_team_id: str, 
+        away_team_id: str
+    ) -> Dict[str, float]:
+        """
+        Maç için kadro feature'larını hesapla.
+        
+        Args:
+            match_id: Maç ID'si
+            home_team_id: Ev sahibi takım ID
+            away_team_id: Deplasman takım ID
+            
+        Returns:
+            Kadro feature'ları dict olarak
+        """
+        features = SquadFeatures()
+        
+        # Ev sahibi analizi
+        home = self.analyze_squad(match_id, home_team_id)
+        features.home_starting_11 = home.starting_count
+        features.home_sub_count = home.sub_count
+        features.home_total_squad = home.total_squad
+        features.home_goalkeepers = home.goalkeeper_count
+        features.home_defenders = home.defender_count
+        features.home_midfielders = home.midfielder_count
+        features.home_forwards = home.forward_count
+        features.home_goals_last_5 = home.total_goals_last_5
+        features.home_assists_last_5 = home.total_assists_last_5
+        features.home_key_players = home.key_players_count
+        features.home_squad_experience = home.squad_experience
+        
+        # Deplasman analizi
+        away = self.analyze_squad(match_id, away_team_id)
+        features.away_starting_11 = away.starting_count
+        features.away_sub_count = away.sub_count
+        features.away_total_squad = away.total_squad
+        features.away_goalkeepers = away.goalkeeper_count
+        features.away_defenders = away.defender_count
+        features.away_midfielders = away.midfielder_count
+        features.away_forwards = away.forward_count
+        features.away_goals_last_5 = away.total_goals_last_5
+        features.away_assists_last_5 = away.total_assists_last_5
+        features.away_key_players = away.key_players_count
+        features.away_squad_experience = away.squad_experience
+        
+        # Karşılaştırma feature'ları
+        home_strength = (
+            home.total_goals_last_5 * 2 + 
+            home.total_assists_last_5 + 
+            home.key_players_count * 3 +
+            home.squad_experience * 10
+        )
+        away_strength = (
+            away.total_goals_last_5 * 2 + 
+            away.total_assists_last_5 + 
+            away.key_players_count * 3 +
+            away.squad_experience * 10
+        )
+        
+        features.squad_strength_diff = home_strength - away_strength
+        features.goals_form_diff = home.total_goals_last_5 - away.total_goals_last_5
+        features.key_players_diff = home.key_players_count - away.key_players_count
+        
+        return features.to_dict()
+    
+    def get_features_without_match(
+        self,
+        home_team_id: str,
+        away_team_id: str
+    ) -> Dict[str, float]:
+        """
+        Maç ID olmadan takım bazlı feature'ları hesapla.
+        Son maçtaki kadroyu referans alır.
+        """
+        features = SquadFeatures()
+        
+        conn = self.get_conn()
+        if conn is None:
+            return features.to_dict()
+        
+        try:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                for team_id, prefix in [(home_team_id, 'home'), (away_team_id, 'away')]:
+                    # Son maçı bul
+                    cur.execute("""
+                        SELECT mpp.match_id
+                        FROM match_player_participation mpp
+                        JOIN matches m ON mpp.match_id = m.id
+                        WHERE mpp.team_id = %s
+                        ORDER BY m.mst_utc DESC
+                        LIMIT 1
+                    """, (team_id,))
+                    
+                    row = cur.fetchone()
+                    if row:
+                        analysis = self.analyze_squad(row['match_id'], team_id)
+                        
+                        if prefix == 'home':
+                            features.home_starting_11 = analysis.starting_count
+                            features.home_sub_count = analysis.sub_count
+                            features.home_total_squad = analysis.total_squad
+                            features.home_goals_last_5 = analysis.total_goals_last_5
+                            features.home_assists_last_5 = analysis.total_assists_last_5
+                            features.home_key_players = analysis.key_players_count
+                            features.home_squad_experience = analysis.squad_experience
+                        else:
+                            features.away_starting_11 = analysis.starting_count
+                            features.away_sub_count = analysis.sub_count
+                            features.away_total_squad = analysis.total_squad
+                            features.away_goals_last_5 = analysis.total_goals_last_5
+                            features.away_assists_last_5 = analysis.total_assists_last_5
+                            features.away_key_players = analysis.key_players_count
+                            features.away_squad_experience = analysis.squad_experience
+            
+            # Karşılaştırma
+            features.goals_form_diff = features.home_goals_last_5 - features.away_goals_last_5
+            features.key_players_diff = features.home_key_players - features.away_key_players
+            
+            return features.to_dict()
+            
+        except Exception as e:
+            print(f"[SquadEngine] Error: {e}")
+            return features.to_dict()
+
+
+# Singleton instance
+_engine: Optional[SquadAnalysisEngine] = None
+
+
+def get_squad_analysis_engine() -> SquadAnalysisEngine:
+    """Singleton squad analysis engine instance döndür"""
+    global _engine
+    if _engine is None:
+        _engine = SquadAnalysisEngine()
+    return _engine
+
+
+if __name__ == "__main__":
+    # Test
+    engine = get_squad_analysis_engine()
+    
+    print("\n🧪 Squad Analysis Engine Test")
+    print("=" * 50)
+    
+    # Test with known team IDs (Galatasaray, Fenerbahce)
+    features = engine.get_features_without_match(
+        home_team_id="test_gs",
+        away_team_id="test_fb"
+    )
+    
+    print("\n📊 Features:")
+    for key, value in features.items():
+        print(f"   {key}: {value:.2f}")
@@ -0,0 +1,194 @@
+"""
+Team Stats Engine
+Takımların oyun tarzı istatistiklerini analiz eder.
+football_team_stats tablosundaki kayıtlardan possession, şut, korner verilerini kullanır.
+"""
+
+import os
+import sys
+import psycopg2
+from typing import Dict
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from data.db import get_clean_dsn
+
+
+class TeamStatsEngine:
+    """
+    Takım istatistikleri için feature engine.
+    
+    Analiz edilen metrikler:
+    - Ortalama top hakimiyeti (possession)
+    - Ortalama isabetli şut
+    - Ortalama korner
+    - Şut/Gol dönüşüm oranı (xG benzeri)
+    - Savunma gücü
+    """
+    
+    def __init__(self):
+        self.conn = None
+    
+    def get_conn(self):
+        if self.conn is None or self.conn.closed:
+            self.conn = psycopg2.connect(get_clean_dsn())
+        return self.conn
+    
+    def get_features(self, team_id: str, before_date: int,
+                     limit: int = 10, max_days: int = 180) -> Dict[str, float]:
+        """
+        Takımın oyun tarzı feature'larını hesapla.
+        
+        Args:
+            team_id: Takım ID
+            before_date: Bu tarihten önceki maçlara bak (ms timestamp)
+            limit: Kaç maç analiz edilecek
+            max_days: Maksimum kaç gün geriye gidilecek
+        
+        Returns:
+            Dict: Team stats feature'ları
+        """
+        if not team_id or len(team_id) < 5:
+            return self._default_features()
+        
+        try:
+            conn = self.get_conn()
+            cur = conn.cursor()
+            
+            min_date = before_date - (max_days * 24 * 60 * 60 * 1000)
+            
+            # Bu takımın son N maçındaki istatistikleri çek
+            cur.execute("""
+                SELECT
+                    mts.possession_percentage,
+                    mts.shots_on_target,
+                    mts.shots_off_target,
+                    mts.total_shots,
+                    mts.corners,
+                    mts.fouls,
+                    m.score_home,
+                    m.score_away,
+                    m.home_team_id
+                FROM football_team_stats mts
+                JOIN matches m ON mts.match_id = m.id
+                WHERE mts.team_id = %s
+                  AND m.mst_utc < %s
+                  AND m.mst_utc > %s
+                  AND m.score_home IS NOT NULL
+                  AND m.sport = 'football'
+                ORDER BY m.mst_utc DESC
+                LIMIT %s
+            """, (team_id, before_date, min_date, limit))
+            
+            stats = cur.fetchall()
+            
+            if not stats:
+                return self._default_features()
+            
+            # İstatistikleri hesapla
+            total_matches = len(stats)
+            
+            possession_sum = 0
+            shots_on_target_sum = 0
+            shots_total_sum = 0
+            corners_sum = 0
+            fouls_sum = 0
+            goals_scored = 0
+            valid_possession_count = 0
+            
+            for stat in stats:
+                poss, sot, soff, total_shots, corners, fouls, sh, sa, home_id = stat
+                
+                if poss and poss > 0:
+                    possession_sum += poss
+                    valid_possession_count += 1
+                
+                if sot:
+                    shots_on_target_sum += sot
+                if total_shots:
+                    shots_total_sum += total_shots
+                if corners:
+                    corners_sum += corners
+                if fouls:
+                    fouls_sum += fouls
+                
+                # Gol hesaplama
+                is_home = (home_id == team_id)
+                goals_scored += sh if is_home else sa
+            
+            avg_possession = possession_sum / valid_possession_count if valid_possession_count > 0 else 50.0
+            avg_shots_on_target = shots_on_target_sum / total_matches if total_matches > 0 else 3.0
+            avg_shots_total = shots_total_sum / total_matches if total_matches > 0 else 10.0
+            avg_corners = corners_sum / total_matches if total_matches > 0 else 4.0
+            avg_fouls = fouls_sum / total_matches if total_matches > 0 else 12.0
+            
+            # Shot conversion rate (xG benzeri)
+            shot_conversion = goals_scored / shots_total_sum if shots_total_sum > 0 else 0.1
+            
+            # Shot accuracy
+            shot_accuracy = shots_on_target_sum / shots_total_sum if shots_total_sum > 0 else 0.35
+            
+            return {
+                'avg_possession': avg_possession / 100,  # Normalize to 0-1
+                'avg_shots_on_target': avg_shots_on_target,
+                'avg_shots_total': avg_shots_total,
+                'avg_corners': avg_corners,
+                'avg_fouls': avg_fouls,
+                'shot_conversion_rate': shot_conversion,
+                'shot_accuracy': shot_accuracy,
+                'attacking_intensity': (avg_shots_total + avg_corners) / 2
+            }
+            
+        except Exception as e:
+            print(f"[TeamStatsEngine] Error: {e}")
+            return self._default_features()
+    
+    def _default_features(self) -> Dict[str, float]:
+        return {
+            'avg_possession': 0.50,
+            'avg_shots_on_target': 3.5,
+            'avg_shots_total': 11.0,
+            'avg_corners': 4.5,
+            'avg_fouls': 12.0,
+            'shot_conversion_rate': 0.10,
+            'shot_accuracy': 0.35,
+            'attacking_intensity': 7.5
+        }
+
+
+# Singleton
+_engine = None
+
+def get_team_stats_engine() -> TeamStatsEngine:
+    global _engine
+    if _engine is None:
+        _engine = TeamStatsEngine()
+    return _engine
+
+
+if __name__ == "__main__":
+    engine = get_team_stats_engine()
+    
+    print("\n🧪 Team Stats Engine Test")
+    print("=" * 50)
+    
+    # Test için örnek takım ID'si al
+    conn = engine.get_conn()
+    cur = conn.cursor()
+    cur.execute("""
+        SELECT DISTINCT mts.team_id, t.name
+        FROM match_team_stats mts
+        JOIN teams t ON mts.team_id = t.id
+        LIMIT 1
+    """)
+    result = cur.fetchone()
+    
+    if result:
+        team_id, team_name = result
+        print(f"Test Takımı: {team_name}")
+        
+        import time
+        features = engine.get_features(team_id, int(time.time() * 1000))
+        
+        print(f"\n📊 Feature'lar:")
+        for k, v in features.items():
+            print(f"   {k}: {v:.3f}")
@@ -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}")
@@ -0,0 +1,507 @@
+"""
+Upset Engine v2 - GLM-5 Tespitleri ile Geliştirilmiş Sürpriz Tespiti
+====================================================================
+
+Yeni Eklenen Faktörler (GLM-5 Analizinden):
+1. MARGIN_ANALIZI - Bookmaker margin > %18 = sürpriz riski
+2. FAVORI_ORAN_TUZAGI - 1.40-1.60 arası en yüksek sürpriz oranı
+3. HAKEM_SURPRIZ_ORANI - Hakemin geçmiş maçlarında ev kayıp oranı
+4. FORM_FARKI_TUZAGI - Form farkı > 40 = "çok iyi görünen" favori tuzak
+
+Orijinal Faktörler:
+- Atmosfer (Avrupa gecesi, taraftar baskısı)
+- Motivasyon asimetrisi (küme düşme vs şampiyon)
+- Yorgunluk (maç yoğunluğu, seyahat)
+- Tarihsel upset pattern
+"""
+
+from typing import Dict, Any, Optional, Tuple, List
+from dataclasses import dataclass, field
+
+try:
+    import psycopg2
+    from psycopg2.extras import RealDictCursor
+except ImportError:
+    psycopg2 = None
+
+
+@dataclass
+class UpsetFactorsV2:
+    """Upset potansiyelini etkileyen faktörler - v2"""
+    # Orijinal faktörler
+    atmosphere_score: float = 0.0
+    motivation_score: float = 0.0
+    fatigue_score: float = 0.0
+    historical_upset_rate: float = 0.0
+    
+    # YENİ FAKTÖRLER (GLM-5)
+    margin_score: float = 0.0           # Bookmaker margin analizi
+    favorite_odds_trap: float = 0.0     # Favori oran tuzağı
+    referee_upset_score: float = 0.0    # Hakem sürpriz oranı
+    form_trap_score: float = 0.0        # Form farkı tuzağı
+    
+    # Toplam
+    total_upset_potential: float = 0.0
+    reasoning: List[str] = field(default_factory=list)
+    
+    # YENİ: Sürpriz skoru (0-100)
+    upset_score: int = 0
+    upset_level: str = "LOW"  # LOW, MEDIUM, HIGH, EXTREME
+
+
+class UpsetEngineV2:
+    """
+    Favori takımın kaybedeceği maçları tespit eder.
+    v2: GLM-5 analizlerinden elde edilen yeni faktörler eklendi.
+    """
+    
+    # Yüksek atmosferli stadyumlar
+    HIGH_ATMOSPHERE_TEAMS = {
+        "galatasaray", "fenerbahce", "besiktas", "trabzonspor",
+        "liverpool", "newcastle", "leeds",
+        "dortmund", "union berlin",
+        "olympiacos", "panathinaikos", "aek athens",
+        "boca juniors", "river plate",
+        "celtic", "rangers", "red star belgrade"
+    }
+    
+    EUROPEAN_COMPETITIONS = {
+        "şampiyonlar ligi", "champions league", "uefa champions league",
+        "avrupa ligi", "europa league", "uefa europa league",
+        "konferans ligi", "conference league", "uefa conference league"
+    }
+    
+    # YENİ: Sürpriz oranları (veritabanı analizinden)
+    # Favori oran aralığına göre sürpriz oranları
+    FAVORITE_ODDS_UPSET_RATES = {
+        (1.10, 1.20): 0.111,  # %11.1 sürpriz
+        (1.20, 1.30): 0.150,  # %15.0 sürpriz
+        (1.30, 1.40): 0.235,  # %23.5 sürpriz
+        (1.40, 1.50): 0.333,  # %33.3 sürpriz ← DİKKAT!
+        (1.50, 1.60): 0.350,  # %35.0 sürpriz ← EN YÜKSEK!
+    }
+    
+    def __init__(self):
+        self.conn = None
+        self._connect_db()
+    
+    def _connect_db(self):
+        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"[UpsetEngineV2] DB connection failed: {e}")
+            self.conn = None
+    
+    def _get_conn(self):
+        if self.conn is None or self.conn.closed:
+            self._connect_db()
+        return self.conn
+    
+    # ═════════════════════════════════════════════════════════════════
+    # YENİ FAKTÖRLER (GLM-5 Analizinden)
+    # ═════════════════════════════════════════════════════════════════
+    
+    def calculate_margin_score(
+        self,
+        odds_data: Dict[str, float]
+    ) -> Tuple[float, List[str]]:
+        """
+        GLM-5 Tespiti: Bookmaker margin analizi
+        
+        Margin > %18 → Bookmaker kendini koruyor, favori riskli
+        Margin > %20 → Yüksek risk, sürpriz bekleniyor
+        """
+        score = 0.0
+        reasons = []
+        
+        ms_h = odds_data.get("ms_h", 0)
+        ms_d = odds_data.get("ms_d", 0)
+        ms_a = odds_data.get("ms_a", 0)
+        
+        if ms_h > 0 and ms_d > 0 and ms_a > 0:
+            margin = (1/ms_h + 1/ms_d + 1/ms_a) - 1
+            
+            if margin > 0.20:
+                score = 0.25
+                reasons.append(f"⚠️ Margin çok yüksek (%{margin*100:.1f}) - Bookmaker risk görüyor!")
+            elif margin > 0.18:
+                score = 0.15
+                reasons.append(f"⚠️ Margin yüksek (%{margin*100:.1f}) - Dikkat!")
+        
+        return score, reasons
+    
+    def calculate_favorite_odds_trap(
+        self,
+        favorite_odds: float,
+        favorite_side: str  # 'home' or 'away'
+    ) -> Tuple[float, List[str]]:
+        """
+        GLM-5 Tespiti: Favori oran tuzağı
+        
+        Veritabanı analizine göre:
+        - 1.40-1.50 arası: %33.3 sürpriz
+        - 1.50-1.60 arası: %35.0 sürpriz (EN YÜKSEK!)
+        - < 1.20: Tuzak oranı şüphesi
+        """
+        score = 0.0
+        reasons = []
+        
+        if favorite_odds <= 0:
+            return score, reasons
+        
+        for (low, high), upset_rate in self.FAVORITE_ODDS_UPSET_RATES.items():
+            if low <= favorite_odds < high:
+                score = upset_rate  # Doğrudan sürpriz olasılığı
+                if upset_rate >= 0.30:
+                    reasons.append(f"🔴 Favori oran {favorite_odds:.2f} - %{upset_rate*100:.0f} sürpriz oranı!")
+                elif upset_rate >= 0.20:
+                    reasons.append(f"⚠️ Favori oran {favorite_odds:.2f} - %{upset_rate*100:.0f} sürpriz riski")
+                break
+        
+        # Çok düşük oran tuzağı
+        if favorite_odds < 1.20:
+            score = max(score, 0.20)
+            reasons.append(f"⚠️ Favori oran çok düşük ({favorite_odds:.2f}) - Tuzak oranı şüphesi")
+        
+        return score, reasons
+    
+    def calculate_referee_upset_score(
+        self,
+        referee_name: str
+    ) -> Tuple[float, List[str]]:
+        """
+        GLM-5 Tespiti: Hakem sürpriz oranı
+        
+        Hakemin yönettiği maçlarda ev sahibi kayıp oranı
+        > %25 → Yüksek sürpriz riski
+        """
+        score = 0.0
+        reasons = []
+        
+        if not referee_name or not self._get_conn():
+            return score, reasons
+        
+        try:
+            cur = self._get_conn().cursor()
+            
+            # Hakemin yönettiği maçlarda sonuçlar
+            cur.execute("""
+                SELECT 
+                    COUNT(*) as total,
+                    SUM(CASE WHEN m.score_home < m.score_away THEN 1 ELSE 0 END) as away_wins,
+                    SUM(CASE WHEN m.score_home = m.score_away THEN 1 ELSE 0 END) as draws
+                FROM match_officials mo
+                JOIN matches m ON m.id = mo.match_id
+                WHERE mo.name = %s AND mo.role_id = 1
+                AND m.score_home IS NOT NULL
+            """, (referee_name,))
+            
+            row = cur.fetchone()
+            cur.close()
+            
+            if row and row[0] and row[0] >= 3:
+                total = row[0]
+                away_wins = row[1] or 0
+                draws = row[2] or 0
+                
+                upset_rate = (away_wins + draws * 0.5) / total
+                
+                if upset_rate > 0.40:
+                    score = 0.25
+                    reasons.append(f"👨‍⚖️ {referee_name}: %{upset_rate*100:.0f} sürpriz oranı (YÜKSEK!)")
+                elif upset_rate > 0.30:
+                    score = 0.15
+                    reasons.append(f"👨‍⚖️ {referee_name}: %{upset_rate*100:.0f} sürpriz oranı")
+        
+        except Exception as e:
+            pass
+        
+        return score, reasons
+    
+    def calculate_form_trap_score(
+        self,
+        home_form_score: float,
+        away_form_score: float,
+        favorite_side: str
+    ) -> Tuple[float, List[str]]:
+        """
+        GLM-5 Tespiti: Form farkı tuzağı
+        
+        Form farkı > 40 → "Çok iyi görünen" favori tuzak
+        Favori formu kötü ama oran düşük → Sürpriz bekleniyor
+        """
+        score = 0.0
+        reasons = []
+        
+        form_diff = home_form_score - away_form_score
+        
+        # Form farkı çok büyük
+        if abs(form_diff) > 40:
+            score = 0.20
+            if form_diff > 0 and favorite_side == 'away':
+                reasons.append(f"🔴 Form tuzağı! Ev sahibi formda ({home_form_score:.0f}) ama deplasman favori")
+            elif form_diff < 0 and favorite_side == 'home':
+                reasons.append(f"🔴 Form tuzağı! Deplasman formda ({away_form_score:.0f}) ama ev sahibi favori")
+        
+        # Favori formu kötü
+        if favorite_side == 'home' and home_form_score < 50:
+            score = max(score, 0.15)
+            reasons.append(f"⚠️ Favori ev sahibi formu düşük ({home_form_score:.0f})")
+        elif favorite_side == 'away' and away_form_score < 50:
+            score = max(score, 0.15)
+            reasons.append(f"⚠️ Favori deplasman formu düşük ({away_form_score:.0f})")
+        
+        return score, reasons
+    
+    # ═════════════════════════════════════════════════════════════════
+    # ORİJİNAL FAKTÖRLER
+    # ═════════════════════════════════════════════════════════════════
+    
+    def calculate_atmosphere_score(
+        self,
+        home_team_name: str,
+        league_name: str,
+        is_cup_match: bool = False
+    ) -> Tuple[float, List[str]]:
+        """Orijinal: Atmosfer skoru"""
+        score = 0.0
+        reasons = []
+        
+        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
+        
+        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
+        
+        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,
+        total_teams: int = 20
+    ) -> Tuple[float, List[str]]:
+        """Orijinal: Motivasyon asimetrisi"""
+        score = 0.0
+        reasons = []
+        
+        if home_position is not None and away_position is not None:
+            position_diff = away_position - home_position
+            relegation_zone = total_teams - 3
+            
+            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")
+            
+            if position_diff < -10:
+                score += 0.15
+                reasons.append(f"📊 {abs(position_diff)} sıra fark")
+        
+        return min(score, 1.0), reasons
+    
+    # ═════════════════════════════════════════════════════════════════
+    # ANA FONKSİYON
+    # ═════════════════════════════════════════════════════════════════
+    
+    def calculate_upset_potential(
+        self,
+        home_team_name: str,
+        home_team_id: str,
+        away_team_name: str,
+        league_name: str,
+        home_position: int = None,
+        away_position: int = None,
+        match_date_ms: int = None,
+        odds_data: Dict[str, float] = None,
+        referee_name: str = None,
+        home_form_score: float = 50.0,
+        away_form_score: float = 50.0,
+        favorite_side: str = None,  # 'home', 'away', or 'draw'
+        favorite_odds: float = None
+    ) -> UpsetFactorsV2:
+        """
+        Tam upset analizi - v2 (GLM-5 geliştirmeleri ile)
+        """
+        factors = UpsetFactorsV2()
+        all_reasons = []
+        
+        # 1. Margin analizi (YENİ)
+        if odds_data:
+            factors.margin_score, reasons = self.calculate_margin_score(odds_data)
+            all_reasons.extend(reasons)
+        
+        # 2. Favori oran tuzağı (YENİ)
+        if favorite_odds and favorite_side:
+            factors.favorite_odds_trap, reasons = self.calculate_favorite_odds_trap(
+                favorite_odds, favorite_side
+            )
+            all_reasons.extend(reasons)
+        
+        # 3. Hakem sürpriz oranı (YENİ)
+        if referee_name:
+            factors.referee_upset_score, reasons = self.calculate_referee_upset_score(
+                referee_name
+            )
+            all_reasons.extend(reasons)
+        
+        # 4. Form tuzağı (YENİ)
+        factors.form_trap_score, reasons = self.calculate_form_trap_score(
+            home_form_score, away_form_score, favorite_side or 'home'
+        )
+        all_reasons.extend(reasons)
+        
+        # 5. Atmosfer (orijinal)
+        factors.atmosphere_score, reasons = self.calculate_atmosphere_score(
+            home_team_name, league_name
+        )
+        all_reasons.extend(reasons)
+        
+        # 6. Motivasyon (orijinal)
+        if home_position is not None and away_position is not None:
+            factors.motivation_score, reasons = self.calculate_motivation_score(
+                home_position, away_position
+            )
+            all_reasons.extend(reasons)
+        
+        # ═══════════════════════════════════════════════════════════
+        # SÜRPRİZ SKORU HESAPLAMA (0-100) - GÜÇLENDİRİLMİŞ v2.1
+        # ═══════════════════════════════════════════════════════════
+        
+        upset_score = 0
+        
+        # Margin (> %18 = +20, > %20 = +30) - GÜÇLENDİRİLDİ
+        if factors.margin_score >= 0.25:
+            upset_score += 30  # Artırıldı: 20 -> 30
+            all_reasons.append("🔴 Margin > %20: Bookmaker büyük risk görüyor!")
+        elif factors.margin_score >= 0.15:
+            upset_score += 20  # Artırıldı: 15 -> 20
+            all_reasons.append("⚠️ Margin > %18: Dikkatli ol!")
+        
+        # Favori oran tuzağı - GÜÇLENDİRİLDİ
+        if factors.favorite_odds_trap >= 0.30:
+            upset_score += 30  # Artırıldı: 25 -> 30
+        elif factors.favorite_odds_trap >= 0.20:
+            upset_score += 25  # Artırıldı: 20 -> 25
+        elif factors.favorite_odds_trap >= 0.15:
+            upset_score += 20  # Artırıldı: 15 -> 20
+        
+        # Hakem
+        if factors.referee_upset_score >= 0.25:
+            upset_score += 20
+        elif factors.referee_upset_score >= 0.15:
+            upset_score += 10
+        
+        # Form tuzağı - GÜÇLENDİRİLDİ
+        if factors.form_trap_score >= 0.20:
+            upset_score += 20  # Artırıldı: 15 -> 20
+        elif factors.form_trap_score >= 0.15:
+            upset_score += 15  # Artırıldı: 10 -> 15
+        
+        # Atmosfer - GÜÇLENDİRİLDİ
+        if factors.atmosphere_score >= 0.40:
+            upset_score += 20  # Artırıldı: 15 -> 20
+        elif factors.atmosphere_score >= 0.25:
+            upset_score += 15  # Artırıldı: 10 -> 15
+        
+        # Motivasyon
+        if factors.motivation_score >= 0.30:
+            upset_score += 15
+        elif factors.motivation_score >= 0.15:
+            upset_score += 10
+        
+        # ═══════════════════════════════════════════════════════════
+        # YENİ: EKSTRA RİSK FAKTÖRLERİ
+        # ═══════════════════════════════════════════════════════════
+        
+        # Deplasman favorisi ekstra risk (+10)
+        if favorite_side == 'away':
+            upset_score += 10
+            all_reasons.append("📍 Deplasman favorisi - ekstra risk!")
+        
+        # Favori formu çok düşük (< 40) = +15
+        if favorite_side == 'home' and home_form_score < 40:
+            upset_score += 15
+            all_reasons.append(f"🔴 Favori ev sahibi formu ÇOK DÜŞÜK ({home_form_score:.0f})")
+        elif favorite_side == 'away' and away_form_score < 40:
+            upset_score += 15
+            all_reasons.append(f"🔴 Favori deplasman formu ÇOK DÜŞÜK ({away_form_score:.0f})")
+        
+        # Çok düşük favori oranı (< 1.30) ama margin yüksek = tuzak şüphesi
+        if favorite_odds and favorite_odds < 1.30 and factors.margin_score >= 0.15:
+            upset_score += 10
+            all_reasons.append(f"⚠️ Düşük oran ({favorite_odds:.2f}) + yüksek margin = TUZAK ŞÜPHESİ!")
+        
+        factors.upset_score = min(upset_score, 100)
+        
+        # Seviye belirle
+        if factors.upset_score >= 60:
+            factors.upset_level = "EXTREME"
+        elif factors.upset_score >= 45:
+            factors.upset_level = "HIGH"
+        elif factors.upset_score >= 30:
+            factors.upset_level = "MEDIUM"
+        else:
+            factors.upset_level = "LOW"
+        
+        # Toplam upset potansiyeli
+        factors.total_upset_potential = min(
+            (factors.margin_score + factors.favorite_odds_trap + 
+             factors.referee_upset_score + factors.form_trap_score +
+             factors.atmosphere_score * 0.5 + factors.motivation_score * 0.5) / 1.5,
+            1.0
+        )
+        
+        factors.reasoning = all_reasons
+        
+        return factors
+
+
+def get_upset_engine_v2():
+    """Singleton pattern"""
+    return UpsetEngineV2()
+
+
+if __name__ == "__main__":
+    # Test
+    engine = get_upset_engine_v2()
+    
+    # Real Madrid vs Getafe test
+    result = engine.calculate_upset_potential(
+        home_team_name="Real Madrid",
+        home_team_id="test",
+        away_team_name="Getafe",
+        league_name="LaLiga",
+        odds_data={"ms_h": 1.25, "ms_d": 3.92, "ms_a": 6.86},
+        referee_name="A. Muniz Ruiz",
+        home_form_score=80.0,
+        away_form_score=56.7,
+        favorite_side="home",
+        favorite_odds=1.25
+    )
+    
+    print(f"\n{'='*60}")
+    print(f"Real Madrid vs Getafe - Sürpriz Analizi")
+    print(f"{'='*60}")
+    print(f"Sürpriz Skoru: {result.upset_score}/100")
+    print(f"Seviye: {result.upset_level}")
+    print(f"\nNedenler:")
+    for reason in result.reasoning:
+        print(f"  {reason}")
@@ -0,0 +1,249 @@
+"""
+Value Betting Calculator
+Expected Value (EV) ve stake önerileri hesaplar.
+"""
+
+from typing import Dict, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class ValueBet:
+    """Value bet analiz sonucu"""
+    bet_type: str  # MS_1, AU25_Üst, KG_Var
+    my_probability: float  # Bizim tahminimiz
+    market_odds: float  # Bahis oranı
+    implied_probability: float  # Oranın ima ettiği olasılık
+    edge: float  # Fark (benim tahmin - implied)
+    expected_value: float  # EV = (prob × odds) - 1
+    is_value: bool  # EV > threshold mı?
+    kelly_fraction: float  # Kelly stake oranı
+    confidence_tier: str  # "banker", "strong", "value", "skip"
+    
+    def to_dict(self) -> Dict:
+        return {
+            'bet_type': self.bet_type,
+            'my_probability': round(self.my_probability, 4),
+            'market_odds': self.market_odds,
+            'implied_probability': round(self.implied_probability, 4),
+            'edge': round(self.edge, 4),
+            'expected_value': round(self.expected_value, 4),
+            'is_value': self.is_value,
+            'kelly_fraction': round(self.kelly_fraction, 4),
+            'confidence_tier': self.confidence_tier,
+        }
+
+
+class ValueCalculator:
+    """
+    Value Betting Calculator
+    
+    Tahminleri oranlarla karşılaştırarak EV hesaplar.
+    """
+    
+    # Eşikler
+    MIN_EDGE_FOR_VALUE = 0.05  # Minimum %5 edge
+    MIN_EDGE_FOR_STRONG = 0.10  # %10+ edge = strong value
+    MIN_EDGE_FOR_BANKER = 0.15  # %15+ edge = banker
+    
+    KELLY_FRACTION = 0.25  # 1/4 Kelly (güvenli)
+    MAX_STAKE_PERCENT = 0.10  # Maksimum bank'ın %10'u
+    
+    def __init__(self):
+        pass
+    
+    def calculate_implied_probability(self, odds: float) -> float:
+        """Bahis oranından implied probability hesapla"""
+        if odds <= 1:
+            return 1.0
+        return 1 / odds
+    
+    def calculate_ev(self, probability: float, odds: float) -> float:
+        """
+        Expected Value hesapla.
+        
+        EV = (Probability × Odds) - 1
+        
+        Pozitif EV = uzun vadede kar
+        Negatif EV = uzun vadede zarar
+        """
+        return (probability * odds) - 1
+    
+    def calculate_kelly_stake(self, probability: float, odds: float) -> float:
+        """
+        Kelly Criterion stake hesapla.
+        
+        Kelly = (p × b - q) / b
+        Burada:
+        - p = kazanma olasılığı
+        - q = kaybetme olasılığı (1 - p)
+        - b = odds - 1 (net kar)
+        """
+        if odds <= 1:
+            return 0
+        
+        b = odds - 1
+        p = probability
+        q = 1 - p
+        
+        kelly = (p * b - q) / b
+        
+        # Negatif veya çok yüksek değerleri sınırla
+        kelly = max(0, min(kelly, self.MAX_STAKE_PERCENT))
+        
+        # Fractional Kelly (daha güvenli)
+        return kelly * self.KELLY_FRACTION
+    
+    def analyze_bet(self, bet_type: str, my_probability: float, 
+                    market_odds: float) -> ValueBet:
+        """
+        Tek bir bahis için value analizi yap.
+        
+        Args:
+            bet_type: Bahis türü (MS_1, AU25_Üst, KG_Var vb.)
+            my_probability: Bizim tahminimiz (0-1 arası)
+            market_odds: Bahis oranı
+        
+        Returns:
+            ValueBet: Analiz sonucu
+        """
+        if market_odds <= 1:
+            return ValueBet(
+                bet_type=bet_type,
+                my_probability=my_probability,
+                market_odds=market_odds,
+                implied_probability=1.0,
+                edge=0,
+                expected_value=-1,
+                is_value=False,
+                kelly_fraction=0,
+                confidence_tier="skip"
+            )
+        
+        implied = self.calculate_implied_probability(market_odds)
+        edge = my_probability - implied
+        ev = self.calculate_ev(my_probability, market_odds)
+        kelly = self.calculate_kelly_stake(my_probability, market_odds)
+        
+        # Tier belirleme
+        if edge >= self.MIN_EDGE_FOR_BANKER and my_probability >= 0.70:
+            tier = "banker"
+        elif edge >= self.MIN_EDGE_FOR_STRONG:
+            tier = "strong"
+        elif edge >= self.MIN_EDGE_FOR_VALUE:
+            tier = "value"
+        else:
+            tier = "skip"
+        
+        return ValueBet(
+            bet_type=bet_type,
+            my_probability=my_probability,
+            market_odds=market_odds,
+            implied_probability=implied,
+            edge=edge,
+            expected_value=ev,
+            is_value=edge >= self.MIN_EDGE_FOR_VALUE,
+            kelly_fraction=kelly,
+            confidence_tier=tier
+        )
+    
+    def analyze_match_predictions(self, predictions: Dict[str, float],
+                                  odds: Dict[str, float]) -> Dict[str, ValueBet]:
+        """
+        Maç için tüm tahminleri analiz et.
+        
+        Args:
+            predictions: Tahminler {'MS_1': 0.55, 'MS_X': 0.25, ...}
+            odds: Oranlar {'MS_1': 1.80, 'MS_X': 3.50, ...}
+        
+        Returns:
+            Dict[str, ValueBet]: Her bahis için value analizi
+        """
+        results = {}
+        
+        for bet_type, probability in predictions.items():
+            if bet_type in odds and odds[bet_type] > 1:
+                results[bet_type] = self.analyze_bet(
+                    bet_type=bet_type,
+                    my_probability=probability,
+                    market_odds=odds[bet_type]
+                )
+        
+        return results
+    
+    def get_best_value_bets(self, value_bets: Dict[str, ValueBet], 
+                            top_n: int = 3) -> list:
+        """En iyi value bet'leri döndür"""
+        valid_bets = [vb for vb in value_bets.values() if vb.is_value]
+        sorted_bets = sorted(valid_bets, key=lambda x: x.expected_value, reverse=True)
+        return sorted_bets[:top_n]
+    
+    def calculate_stake(self, value_bet: ValueBet, bankroll: float,
+                        use_kelly: bool = True) -> float:
+        """
+        Önerilen stake miktarını hesapla.
+        
+        Args:
+            value_bet: Value bet analizi
+            bankroll: Toplam bütçe
+            use_kelly: Kelly criterion kullan mı?
+        
+        Returns:
+            float: Önerilen stake miktarı
+        """
+        if not value_bet.is_value:
+            return 0
+        
+        if use_kelly:
+            return bankroll * value_bet.kelly_fraction
+        else:
+            # Tier bazlı sabit stake
+            tier_stakes = {
+                "banker": 0.05,
+                "strong": 0.03,
+                "value": 0.02,
+                "skip": 0
+            }
+            return bankroll * tier_stakes.get(value_bet.confidence_tier, 0)
+
+
+# Singleton
+_calculator = None
+
+def get_value_calculator() -> ValueCalculator:
+    global _calculator
+    if _calculator is None:
+        _calculator = ValueCalculator()
+    return _calculator
+
+
+if __name__ == "__main__":
+    calc = get_value_calculator()
+    
+    print("\n🧪 Value Calculator Test")
+    print("=" * 50)
+    
+    # Test senaryoları
+    test_cases = [
+        {"bet": "MS_1", "prob": 0.70, "odds": 1.60},  # High prob, low odds
+        {"bet": "MS_1", "prob": 0.55, "odds": 1.90},  # Medium prob, good odds
+        {"bet": "MS_1", "prob": 0.60, "odds": 2.10},  # VALUE!
+        {"bet": "AU25_Üst", "prob": 0.65, "odds": 1.85},  # VALUE!
+        {"bet": "KG_Var", "prob": 0.50, "odds": 1.70},  # No value
+    ]
+    
+    for tc in test_cases:
+        result = calc.analyze_bet(tc["bet"], tc["prob"], tc["odds"])
+        
+        status_emoji = "✅" if result.is_value else "❌"
+        tier_emoji = {"banker": "🎯", "strong": "💪", "value": "✓", "skip": "⏭️"}
+        
+        print(f"\n{status_emoji} {tc['bet']}")
+        print(f"   Tahmin: {tc['prob']:.0%} | Oran: {tc['odds']:.2f} | Implied: {result.implied_probability:.0%}")
+        print(f"   Edge: {result.edge:+.1%} | EV: {result.expected_value:+.1%}")
+        print(f"   Tier: {tier_emoji.get(result.confidence_tier, '')} {result.confidence_tier.upper()}")
+        print(f"   Kelly Stake: {result.kelly_fraction:.2%} of bankroll")
+        
+        if result.is_value:
+            stake = calc.calculate_stake(result, 1000)
+            print(f"   💰 Önerilen Stake (1000 TL bank): {stake:.2f} TL")
@@ -0,0 +1,415 @@
+"""
+Value Detection Engine
+======================
+The Smart Way to Beat the Bookmakers
+
+This engine doesn't just predict winners - it finds VALUE.
+The key insight: We don't need to predict the winner, we need to find
+where the bookmaker made a mistake in their odds.
+
+Core Philosophy:
+- High Margin = High Uncertainty = Potential Value
+- Model Probability > Implied Probability = Value Bet
+- The goal is NOT to predict correctly, but to find +EV bets
+
+Author: AI Engine V21
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+from collections import defaultdict
+
+
+@dataclass
+class ValueBet:
+    """Represents a value bet opportunity"""
+    outcome: str  # "1", "X", "2"
+    model_probability: float  # Our model's probability (0-1)
+    implied_probability: float  # Bookmaker's implied probability (0-1)
+    odds: float  # Bookmaker's odds
+    edge: float  # model_prob - implied_prob (as percentage)
+    expected_value: float  # EV = (prob * odds) - 1
+    kelly_fraction: float  # Optimal bet size
+    confidence: str  # "HIGH", "MEDIUM", "LOW"
+    reasons: List[str]  # Why this is value
+    
+    def to_dict(self) -> dict:
+        return {
+            "outcome": self.outcome,
+            "model_prob": round(self.model_probability * 100, 1),
+            "implied_prob": round(self.implied_probability * 100, 1),
+            "odds": self.odds,
+            "edge": round(self.edge * 100, 1),
+            "ev": round(self.expected_value * 100, 1),
+            "kelly": round(self.kelly_fraction * 100, 1),
+            "confidence": self.confidence,
+            "reasons": self.reasons
+        }
+
+
+@dataclass
+class MarginAnalysis:
+    """Analysis of bookmaker margin"""
+    raw_margin: float  # Sum of raw implied probabilities - 1
+    true_margin: float  # Adjusted for favorite-longshot bias
+    favorite_outcome: str
+    favorite_odds: float
+    uncertainty_level: str  # "LOW", "MEDIUM", "HIGH", "EXTREME"
+    
+    def to_dict(self) -> dict:
+        return {
+            "raw_margin": round(self.raw_margin * 100, 1),
+            "true_margin": round(self.true_margin * 100, 1),
+            "favorite": self.favorite_outcome,
+            "favorite_odds": self.favorite_odds,
+            "uncertainty": self.uncertainty_level
+        }
+
+
+class ValueDetectionEngine:
+    """
+    The Smart Betting Engine
+    
+    This engine finds value bets by comparing model probabilities
+    with bookmaker implied probabilities.
+    
+    Key Insights:
+    1. Margin > 18% → Bookmaker is unsure, potential value on underdog
+    2. Margin > 20% → Bookmaker sees high risk, BIG potential value
+    3. Favorite odds 1.40-1.60 → Highest upset rate historically
+    4. Away favorites have higher upset rate than home favorites
+    """
+    
+    # Historical upset rates by favorite odds range
+    UPSET_RATES = {
+        (1.00, 1.25): 0.08,   # 8% upset rate
+        (1.25, 1.40): 0.18,   # 18% upset rate
+        (1.40, 1.60): 0.33,   # 33% upset rate - DANGER ZONE
+        (1.60, 1.80): 0.28,   # 28% upset rate
+        (1.80, 2.00): 0.35,   # 35% upset rate
+        (2.00, 2.50): 0.42,   # 42% upset rate
+        (2.50, 3.00): 0.45,   # 45% upset rate
+        (3.00, 5.00): 0.55,   # 55% upset rate
+    }
+    
+    # Margin thresholds
+    MARGIN_LOW = 0.06      # 6% - bookmaker very confident
+    MARGIN_MEDIUM = 0.12   # 12% - normal margin
+    MARGIN_HIGH = 0.18     # 18% - bookmaker unsure
+    MARGIN_EXTREME = 0.22  # 22% - bookmaker very unsure
+    
+    def __init__(self):
+        self.historical_data = []  # For learning
+        self.value_threshold = 0.03  # Minimum 3% edge to consider value
+        
+    def calculate_margin(self, odds_1: float, odds_x: float, odds_2: float) -> MarginAnalysis:
+        """
+        Calculate bookmaker margin and analyze uncertainty.
+        
+        Higher margin = More uncertainty = More potential value
+        """
+        if not all([odds_1 > 1, odds_x > 1, odds_2 > 1]):
+            return MarginAnalysis(0, 0, "X", 0, "UNKNOWN")
+        
+        # Raw implied probabilities
+        imp_1 = 1 / odds_1
+        imp_x = 1 / odds_x
+        imp_2 = 1 / odds_2
+        
+        raw_margin = imp_1 + imp_x + imp_2 - 1
+        
+        # Determine favorite
+        if odds_1 <= odds_x and odds_1 <= odds_2:
+            favorite_outcome = "1"
+            favorite_odds = odds_1
+        elif odds_2 <= odds_1 and odds_2 <= odds_x:
+            favorite_outcome = "2"
+            favorite_odds = odds_2
+        else:
+            favorite_outcome = "X"
+            favorite_odds = odds_x
+        
+        # Adjust for favorite-longshot bias
+        # Bookmakers typically overprice longshots
+        true_margin = raw_margin * 0.85  # Simplified adjustment
+        
+        # Determine uncertainty level
+        if raw_margin < self.MARGIN_LOW:
+            uncertainty = "LOW"
+        elif raw_margin < self.MARGIN_MEDIUM:
+            uncertainty = "MEDIUM"
+        elif raw_margin < self.MARGIN_HIGH:
+            uncertainty = "HIGH"
+        else:
+            uncertainty = "EXTREME"
+        
+        return MarginAnalysis(
+            raw_margin=raw_margin,
+            true_margin=true_margin,
+            favorite_outcome=favorite_outcome,
+            favorite_odds=favorite_odds,
+            uncertainty_level=uncertainty
+        )
+    
+    def get_historical_upset_rate(self, favorite_odds: float) -> float:
+        """Get historical upset rate for given favorite odds"""
+        for (low, high), rate in self.UPSET_RATES.items():
+            if low <= favorite_odds < high:
+                return rate
+        return 0.40  # Default for very high odds
+    
+    def calculate_edge(
+        self,
+        model_prob: float,
+        odds: float,
+        margin: float
+    ) -> Tuple[float, float]:
+        """
+        Calculate the edge (advantage) we have over the bookmaker.
+        
+        Returns: (edge, expected_value)
+        
+        Edge = Model Probability - True Implied Probability
+        EV = (Probability * Odds) - 1
+        """
+        if odds <= 1:
+            return 0, -1
+        
+        # Raw implied probability
+        implied = 1 / odds
+        
+        # Adjust for margin (proportional adjustment)
+        # This gives us the "true" implied probability
+        # Assuming bookmaker spreads margin proportionally
+        true_implied = implied  # Simplified - could be more sophisticated
+        
+        edge = model_prob - true_implied
+        ev = (model_prob * odds) - 1
+        
+        return edge, ev
+    
+    def calculate_kelly_fraction(
+        self,
+        probability: float,
+        odds: float,
+        half_kelly: bool = True
+    ) -> float:
+        """
+        Calculate optimal bet size using Kelly Criterion.
+        
+        Kelly = (p * b - 1) / (b - 1)
+        where b = odds - 1
+        
+        We use half Kelly for safety.
+        """
+        if odds <= 1:
+            return 0
+        
+        b = odds - 1
+        kelly = (probability * b - 1) / b
+        
+        # Don't bet if negative
+        if kelly < 0:
+            return 0
+        
+        # Use half Kelly for safety
+        if half_kelly:
+            kelly = kelly / 2
+        
+        # Cap at 10% of bankroll
+        return min(kelly, 0.10)
+    
+    def find_value_bets(
+        self,
+        model_probs: Dict[str, float],
+        odds: Dict[str, float],
+        match_context: Optional[Dict] = None
+    ) -> List[ValueBet]:
+        """
+        Find all value bets in a match.
+        
+        This is the MAIN method - it finds where we have an edge.
+        
+        Args:
+            model_probs: {"1": 0.55, "X": 0.25, "2": 0.20}
+            odds: {"1": 1.25, "X": 4.50, "2": 8.00}
+            match_context: Additional context (form, h2h, etc.)
+        
+        Returns:
+            List of ValueBet objects, sorted by edge
+        """
+        value_bets = []
+        
+        # Calculate margin
+        margin_analysis = self.calculate_margin(
+            odds.get("1", 0),
+            odds.get("X", 0),
+            odds.get("2", 0)
+        )
+        
+        # Analyze each outcome
+        for outcome in ["1", "X", "2"]:
+            prob = model_probs.get(outcome, 0)
+            odd = odds.get(outcome, 0)
+            
+            if prob <= 0 or odd <= 1:
+                continue
+            
+            edge, ev = self.calculate_edge(prob, odd, margin_analysis.raw_margin)
+            kelly = self.calculate_kelly_fraction(prob, odd)
+            
+            # Determine if this is a value bet
+            reasons = []
+            
+            # 1. Basic edge
+            if edge > self.value_threshold:
+                reasons.append(f"Edge: +{round(edge*100, 1)}% over bookmaker")
+            
+            # 2. High margin bonus
+            if margin_analysis.raw_margin > self.MARGIN_HIGH:
+                reasons.append(f"High margin ({round(margin_analysis.raw_margin*100, 1)}%) = uncertainty")
+                
+                # Boost edge for underdogs in high margin matches
+                if outcome != margin_analysis.favorite_outcome:
+                    edge += 0.02  # 2% bonus
+                    reasons.append("Underdog in high-margin match = bonus value")
+            
+            # 3. Favorite odds trap
+            fav_odds = margin_analysis.favorite_odds
+            if margin_analysis.favorite_outcome != outcome:
+                upset_rate = self.get_historical_upset_rate(fav_odds)
+                if upset_rate > 0.25:
+                    reasons.append(f"Favorite odds {fav_odds} has {round(upset_rate*100)}% upset rate")
+                    
+                    # Extra bonus for 1.40-1.60 range
+                    if 1.40 <= fav_odds <= 1.60:
+                        edge += 0.03
+                        reasons.append("DANGER ZONE: 1.40-1.60 odds = highest upset risk")
+            
+            # 4. Away favorite risk
+            if margin_analysis.favorite_outcome == "2" and outcome == "1":
+                edge += 0.015
+                reasons.append("Away favorite = extra home value")
+            
+            # 5. EV positive
+            if ev > 0:
+                reasons.append(f"Positive EV: +{round(ev*100, 1)}%")
+            
+            # Only add if we have reasons (value detected)
+            if reasons and edge > 0:
+                # Determine confidence
+                if edge > 0.08 or (edge > 0.05 and kelly > 0.03):
+                    confidence = "HIGH"
+                elif edge > 0.05:
+                    confidence = "MEDIUM"
+                else:
+                    confidence = "LOW"
+                
+                value_bets.append(ValueBet(
+                    outcome=outcome,
+                    model_probability=prob,
+                    implied_probability=1/odd,
+                    odds=odd,
+                    edge=edge,
+                    expected_value=ev,
+                    kelly_fraction=kelly,
+                    confidence=confidence,
+                    reasons=reasons
+                ))
+        
+        # Sort by edge (highest first)
+        value_bets.sort(key=lambda x: x.edge, reverse=True)
+        
+        return value_bets
+    
+    def predict_with_value(
+        self,
+        model_probs: Dict[str, float],
+        odds: Dict[str, float],
+        match_context: Optional[Dict] = None
+    ) -> Dict:
+        """
+        Make a prediction based on VALUE, not just probability.
+        
+        This is the smart way to bet:
+        - If there's clear value on one outcome → Bet it
+        - If there's no value → NO BET (don't force it)
+        - If margin is extreme → Look for underdog value
+        
+        Returns:
+            {
+                "best_value": ValueBet or None,
+                "alternative_value": ValueBet or None,
+                "margin_analysis": MarginAnalysis,
+                "recommendation": str,
+                "confidence": str
+            }
+        """
+        margin_analysis = self.calculate_margin(
+            odds.get("1", 0),
+            odds.get("X", 0),
+            odds.get("2", 0)
+        )
+        
+        value_bets = self.find_value_bets(model_probs, odds, match_context)
+        
+        result = {
+            "margin_analysis": margin_analysis.to_dict(),
+            "value_bets": [vb.to_dict() for vb in value_bets],
+            "best_value": None,
+            "alternative_value": None,
+            "recommendation": "NO_BET",
+            "confidence": "LOW",
+            "reasoning": []
+        }
+        
+        if not value_bets:
+            result["reasoning"].append("No value detected in any outcome")
+            result["reasoning"].append("Bookmaker odds are efficient for this match")
+            return result
+        
+        # Get best value bet
+        best = value_bets[0]
+        result["best_value"] = best.to_dict()
+        
+        if len(value_bets) > 1:
+            result["alternative_value"] = value_bets[1].to_dict()
+        
+        # Determine recommendation
+        if best.confidence == "HIGH" and best.edge > 0.05:
+            result["recommendation"] = f"BET_{best.outcome}"
+            result["confidence"] = "HIGH"
+            result["reasoning"] = best.reasons
+            result["reasoning"].append(f"Strong value on {best.outcome} with {round(best.edge*100, 1)}% edge")
+        
+        elif best.confidence == "MEDIUM" or best.edge > 0.03:
+            result["recommendation"] = f"CONSIDER_{best.outcome}"
+            result["confidence"] = "MEDIUM"
+            result["reasoning"] = best.reasons
+            result["reasoning"].append(f"Moderate value on {best.outcome}")
+        
+        else:
+            result["recommendation"] = "NO_BET"
+            result["confidence"] = "LOW"
+            result["reasoning"].append("Edge too small to justify bet")
+            result["reasoning"].append(f"Best edge: {round(best.edge*100, 1)}% (need >3%)")
+        
+        # Add margin context
+        if margin_analysis.uncertainty_level == "EXTREME":
+            result["reasoning"].append("⚠️ EXTREME margin - high volatility match")
+        elif margin_analysis.uncertainty_level == "HIGH":
+            result["reasoning"].append("⚠️ High margin - bookmaker sees risk")
+        
+        return result
+
+
+# Singleton instance
+_engine_instance = None
+
+def get_value_detection_engine() -> ValueDetectionEngine:
+    """Get the singleton instance"""
+    global _engine_instance
+    if _engine_instance is None:
+        _engine_instance = ValueDetectionEngine()
+    return _engine_instance
@@ -0,0 +1,167 @@
+"""
+Shared VQWEN feature contract
+=============================
+
+One place defines how VQWEN features are produced.
+Both training and runtime inference must use this module so the model sees
+the same feature semantics in historical data and live analysis.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+FEATURE_COLUMNS = [
+    "elo_diff",
+    "h_xg",
+    "a_xg",
+    "total_xg",
+    "pow_diff",
+    "rest_diff",
+    "h_fat",
+    "a_fat",
+    "imp_h",
+    "imp_d",
+    "imp_a",
+    "h_xi",
+    "a_xi",
+    "h2h_h_wr",
+    "form_diff",
+]
+
+
+@dataclass(slots=True)
+class VqwenFeatureInput:
+    home_elo: float
+    away_elo: float
+    home_avg_goals_scored: float
+    away_avg_goals_scored: float
+    home_avg_goals_conceded: float
+    away_avg_goals_conceded: float
+    home_avg_shots_on_target: float
+    away_avg_shots_on_target: float
+    home_avg_possession: float
+    away_avg_possession: float
+    home_rest_days: float
+    away_rest_days: float
+    implied_prob_home: float
+    implied_prob_draw: float
+    implied_prob_away: float
+    home_lineup_availability: float = 1.0
+    away_lineup_availability: float = 1.0
+    h2h_home_win_rate: float = 0.5
+    home_form_score: float = 0.0
+    away_form_score: float = 0.0
+    league_avg_goals: float = 2.6
+    referee_avg_goals: float = 2.6
+    referee_home_bias: float = 0.0
+    home_squad_strength: float = 0.5
+    away_squad_strength: float = 0.5
+    home_key_players: float = 0.0
+    away_key_players: float = 0.0
+    missing_players_impact: float = 0.0
+
+
+def fatigue_multiplier(rest_days: float) -> float:
+    if rest_days < 3.0:
+        return 0.85
+    if rest_days < 5.0:
+        return 0.95
+    return 1.0
+
+
+def clamp(value: float, lower: float, upper: float) -> float:
+    return min(max(float(value), lower), upper)
+
+
+def build_vqwen_feature_row(values: VqwenFeatureInput) -> dict[str, float]:
+    home_fatigue = fatigue_multiplier(values.home_rest_days)
+    away_fatigue = fatigue_multiplier(values.away_rest_days)
+    goal_environment = (
+        float(values.league_avg_goals) + float(values.referee_avg_goals)
+    ) / 2.0
+    goal_environment_multiplier = clamp(goal_environment / 2.6, 0.85, 1.2)
+    squad_diff = float(values.home_squad_strength) - float(values.away_squad_strength)
+    key_player_diff = float(values.home_key_players) - float(values.away_key_players)
+    missing_penalty = clamp(float(values.missing_players_impact), 0.0, 1.0)
+    referee_bias = clamp(float(values.referee_home_bias), -0.25, 0.25)
+    home_squad_multiplier = clamp(
+        1.0 + squad_diff * 0.08 + key_player_diff * 0.025 - missing_penalty * 0.08 + referee_bias * 0.03,
+        0.82,
+        1.18,
+    )
+    away_squad_multiplier = clamp(
+        1.0 - squad_diff * 0.08 - key_player_diff * 0.025 - missing_penalty * 0.08 - referee_bias * 0.03,
+        0.82,
+        1.18,
+    )
+
+    home_xg = max(
+        0.05,
+        (
+            float(values.home_avg_goals_scored)
+            + float(values.away_avg_goals_conceded)
+        )
+        / 2.0,
+    ) * home_fatigue * goal_environment_multiplier * home_squad_multiplier
+    away_xg = max(
+        0.05,
+        (
+            float(values.away_avg_goals_scored)
+            + float(values.home_avg_goals_conceded)
+        )
+        / 2.0,
+    ) * away_fatigue * goal_environment_multiplier * away_squad_multiplier
+
+    home_power = (
+        float(values.home_avg_goals_scored) * 5.0
+        - float(values.home_avg_goals_conceded) * 5.0
+        + float(values.home_avg_shots_on_target) * 2.0
+        + float(values.home_avg_possession) * 0.1
+        + float(values.home_squad_strength) * 3.0
+        + float(values.home_key_players) * 0.8
+        + referee_bias * 6.0
+    )
+    away_power = (
+        float(values.away_avg_goals_scored) * 5.0
+        - float(values.away_avg_goals_conceded) * 5.0
+        + float(values.away_avg_shots_on_target) * 2.0
+        + float(values.away_avg_possession) * 0.1
+        + float(values.away_squad_strength) * 3.0
+        + float(values.away_key_players) * 0.8
+        - referee_bias * 6.0
+    )
+
+    return {
+        "elo_diff": float(values.home_elo) - float(values.away_elo),
+        "h_xg": home_xg,
+        "a_xg": away_xg,
+        "total_xg": home_xg + away_xg,
+        "pow_diff": home_power - away_power,
+        "rest_diff": float(values.home_rest_days) - float(values.away_rest_days),
+        "h_fat": home_fatigue,
+        "a_fat": away_fatigue,
+        "imp_h": clamp(values.implied_prob_home, 0.01, 0.98),
+        "imp_d": clamp(values.implied_prob_draw, 0.01, 0.98),
+        "imp_a": clamp(values.implied_prob_away, 0.01, 0.98),
+        # Column names are preserved for artifact compatibility.
+        # Semantics are now "pre-match lineup availability" instead of leaked
+        # post-match starting-XI counts.
+        "h_xi": clamp(values.home_lineup_availability, 0.0, 1.0),
+        "a_xi": clamp(values.away_lineup_availability, 0.0, 1.0),
+        "h2h_h_wr": clamp(values.h2h_home_win_rate, 0.0, 1.0),
+        "form_diff": (
+            float(values.home_form_score)
+            - float(values.away_form_score)
+            + squad_diff * 1.5
+            + key_player_diff * 0.35
+            + referee_bias * 2.0
+            - missing_penalty * 1.75
+        ),
+    }
+
+
+def row_to_array(row: dict[str, float]) -> np.ndarray:
+    return np.array([[float(row[column]) for column in FEATURE_COLUMNS]], dtype=np.float64)
@@ -0,0 +1,430 @@
+from __future__ import annotations
+
+import os
+import sys
+import asyncio
+import time
+from contextlib import asynccontextmanager
+from typing import Any
+
+from datetime import datetime
+
+import uvicorn
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import subprocess
+from pydantic import BaseModel
+
+try:
+    from models.basketball_v25 import get_basketball_v25_predictor
+    HAS_BASKETBALL = True
+except ImportError:
+    HAS_BASKETBALL = False
+from services.single_match_orchestrator import get_single_match_orchestrator
+from services.v26_shadow_engine import get_v26_shadow_engine
+from models.league_model import get_league_model_loader
+
+load_dotenv()
+
+if sys.stdout and hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+if sys.stderr and hasattr(sys.stderr, "reconfigure"):
+    sys.stderr.reconfigure(encoding="utf-8")
+
+
+class CouponRequest(BaseModel):
+    match_ids: list[str]
+    strategy: str | None = "BALANCED"
+    max_matches: int | None = None
+    min_confidence: float | None = None
+
+
+class RetrainRequest(BaseModel):
+    reason: str | None = "manual"
+    markets: str | None = None  # comma-separated, e.g. "MS,OU25,BTTS"
+    trials: int | None = 50
+
+
+# ─── Retrain state tracking ──────────────────────────────────
+_retrain_state: dict[str, Any] = {
+    "running": False,
+    "last_started": None,
+    "last_completed": None,
+    "last_status": None,
+    "last_error": None,
+    "pid": None,
+}
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    try:
+        print("🚀 Initializing V28 orchestrator...", flush=True)
+        get_single_match_orchestrator()
+        get_v26_shadow_engine()
+        print("✅ V28 orchestrator ready", flush=True)
+    except Exception as error:
+        print(f"❌ Failed to initialize orchestrator: {error}", flush=True)
+        import traceback
+
+        traceback.print_exc()
+
+    yield
+
+
+app = FastAPI(
+    title="Suggest-Bet AI Engine",
+    version="28.0.0",
+    description="V28 Single Match Prediction Package API",
+    lifespan=lifespan,
+)
+
+
+def _parse_cors_origins() -> list[str]:
+    raw = os.getenv("CORS_ALLOW_ORIGINS", "").strip()
+    if raw:
+        return [item.strip() for item in raw.split(",") if item.strip()]
+    # Dev-safe defaults + production domains.
+    return [
+        "http://localhost:3000",
+        "http://127.0.0.1:3000",
+        "http://localhost:3001",
+        "http://127.0.0.1:3001",
+        "http://localhost:3005",
+        "http://127.0.0.1:3005",
+        "https://ui-suggestbet.bilgich.com",
+        "https://suggestbet.bilgich.com",
+        "https://iddaai.com",
+        "https://www.iddaai.com",
+    ]
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=_parse_cors_origins(),
+    allow_origin_regex=r"^https?://(localhost|127\.0\.0\.1)(:\d+)?$",
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.exception_handler(Exception)
+async def global_exception_handler(_: Request, exc: Exception):
+    import traceback
+
+    print(f"💥 ERROR: {exc}", flush=True)
+    traceback.print_exc()
+    return JSONResponse(
+        status_code=500,
+        content={"message": f"Internal Server Error: {str(exc)}"},
+    )
+
+
+@app.get("/")
+def read_root() -> dict[str, Any]:
+    return {
+        "status": "Suggest-Bet AI Engine v28",
+        "engine": "V28 Single Match Orchestrator",
+        "mode": os.getenv("AI_ENGINE_MODE", "v28"),
+        "routes": [
+            "POST /v20plus/analyze/{match_id}",
+            "GET /v20plus/analyze-htms/{match_id}",
+            "GET /v20plus/analyze-htft/{match_id}",
+            "GET /v20plus/reversal-watchlist",
+            "POST /v20plus/coupon",
+            "GET /v20plus/daily-banker",
+            "POST /v1/admin/retrain",
+            "GET /v1/admin/retrain/status",
+        ],
+    }
+
+
+@app.get("/health")
+def health_check() -> dict[str, Any]:
+    try:
+        orchestrator = get_single_match_orchestrator()
+        shadow_engine = get_v26_shadow_engine()
+
+        # Per-market V25 model status
+        v25_readiness: dict[str, Any] = {"fully_loaded": False}
+        try:
+            v25_predictor = orchestrator._get_v25_predictor()
+            v25_readiness = v25_predictor.readiness_summary()
+        except Exception as v25_err:
+            v25_readiness = {"fully_loaded": False, "error": str(v25_err)}
+
+        if HAS_BASKETBALL:
+            basketball_predictor = get_basketball_v25_predictor()
+            basketball_readiness = basketball_predictor.readiness_summary()
+            ready = bool(basketball_readiness.get("fully_loaded", True))
+        else:
+            basketball_readiness = {"fully_loaded": False, "error": "Basketball module not found"}
+            ready = True
+
+        league_readiness = get_league_model_loader().readiness_summary()
+        overall_ready = ready and v25_readiness.get("fully_loaded", False)
+        return {
+            "status": "healthy" if overall_ready else "degraded",
+            "engine": "v28.main",
+            "mode": os.getenv("AI_ENGINE_MODE", "v28"),
+            "ready": overall_ready,
+            "v25_football": v25_readiness,
+            "league_specific": league_readiness,
+            "basketball_v25": basketball_readiness,
+            "v26_shadow": shadow_engine.readiness_summary(),
+            "prediction_service_ready": True,
+            "model_loaded": overall_ready,
+            "orchestrator_mode": getattr(orchestrator, "engine_mode", "v28"),
+        }
+    except Exception as error:
+        return {"status": "unhealthy", "ready": False, "error": str(error)}
+
+
+_REQUIRED_RESPONSE_FIELDS = ("match_info", "market_board", "main_pick", "bet_summary", "data_quality")
+
+
+@app.post("/v20plus/analyze/{match_id}")
+async def analyze_match_v20plus(match_id: str) -> dict[str, Any]:
+    started_at = time.time()
+    orchestrator = get_single_match_orchestrator()
+    result = await asyncio.to_thread(orchestrator.analyze_match, match_id)
+    elapsed_ms = int((time.time() - started_at) * 1000)
+
+    if not result:
+        raise HTTPException(status_code=404, detail=f"Match not found: {match_id}")
+
+    # Response validation: log missing required fields (non-fatal)
+    missing_fields = [f for f in _REQUIRED_RESPONSE_FIELDS if f not in result]
+    if missing_fields:
+        print(f"⚠️ [API] analyze/{match_id} response missing fields: {missing_fields} ({elapsed_ms}ms)")
+
+    result["timing_ms"] = elapsed_ms
+    return result
+
+
+@app.get("/v20plus/analyze-htms/{match_id}")
+async def analyze_match_htms_v20plus(match_id: str) -> dict[str, Any]:
+    orchestrator = get_single_match_orchestrator()
+    result = await asyncio.to_thread(orchestrator.analyze_match_htms, match_id)
+    if not result:
+        raise HTTPException(status_code=404, detail=f"Match not found: {match_id}")
+    return result
+
+
+@app.get("/v20plus/analyze-htft/{match_id}")
+async def analyze_match_htft_v20plus(match_id: str, timeout_sec: int = 30) -> dict[str, Any]:
+    # Small, explicit endpoint for HT/FT inspection and debugging in FE/Postman.
+    if timeout_sec < 3 or timeout_sec > 120:
+        raise HTTPException(status_code=400, detail="timeout_sec must be between 3 and 120")
+
+    orchestrator = get_single_match_orchestrator()
+    started_at = time.time()
+
+    try:
+        result = await asyncio.wait_for(
+            asyncio.to_thread(orchestrator.analyze_match, match_id),
+            timeout=float(timeout_sec),
+        )
+    except asyncio.TimeoutError as error:
+        raise HTTPException(
+            status_code=504,
+            detail=f"Analyze timeout after {timeout_sec}s for match_id={match_id}",
+        ) from error
+
+    if not result:
+        raise HTTPException(status_code=404, detail=f"Match not found: {match_id}")
+
+    risk = result.get("risk", {})
+    market_board = result.get("market_board", {})
+    htft_probs = market_board.get("HTFT", {}).get("probs", {}) or risk.get("ht_ft_probs", {})
+    top_reversal_pick = None
+    top_reversal_prob = 0.0
+    if htft_probs:
+        prob_12 = float(htft_probs.get("1/2", 0.0))
+        prob_21 = float(htft_probs.get("2/1", 0.0))
+        if prob_21 >= prob_12:
+            top_reversal_pick = "2/1"
+            top_reversal_prob = prob_21
+        else:
+            top_reversal_pick = "1/2"
+            top_reversal_prob = prob_12
+
+    overall_htft_pick = None
+    overall_htft_prob = 0.0
+    if htft_probs:
+        overall_htft_pick, overall_htft_prob = max(
+            htft_probs.items(),
+            key=lambda item: float(item[1]),
+        )
+    return {
+        "engine": "v28.main",
+        "match_info": result.get("match_info", {}),
+        "timing_ms": int((time.time() - started_at) * 1000),
+        "ht_ft_probs": htft_probs,
+        "top_reversal_pick": top_reversal_pick,
+        "top_reversal_prob": round(float(top_reversal_prob), 4),
+        "overall_htft_pick": overall_htft_pick,
+        "overall_htft_pick_prob": round(float(overall_htft_prob), 4),
+        "surprise_hunter": result.get("surprise_hunter", {}),
+        "ht_ft_reversal_radar": result.get("ht_ft_reversal_radar", {}),
+        "first_half_result": result.get("market_board", {}).get("first_half_result", {}),
+        "main_pick": result.get("main_pick", {}),
+        "bet_summary": result.get("bet_summary", {}),
+    }
+
+
+@app.post("/v20plus/coupon")
+async def generate_coupon_v20plus(request: CouponRequest) -> dict[str, Any]:
+    orchestrator = get_single_match_orchestrator()
+    return await asyncio.to_thread(
+        orchestrator.build_coupon,
+        request.match_ids,
+        request.strategy or "BALANCED",
+        request.max_matches,
+        request.min_confidence,
+    )
+
+
+@app.get("/v20plus/daily-banker")
+async def get_daily_banker_v20plus(count: int = 3) -> dict[str, Any]:
+    if count < 1:
+        raise HTTPException(status_code=400, detail="count must be >= 1")
+
+    orchestrator = get_single_match_orchestrator()
+    bankers = await asyncio.to_thread(orchestrator.get_daily_bankers, count)
+    return {"count": len(bankers), "bankers": bankers}
+
+@app.get("/v20plus/reversal-watchlist")
+async def get_reversal_watchlist_v20plus(
+    count: int = 20,
+    horizon_hours: int = 72,
+    min_score: float = 45.0,
+    top_leagues_only: bool = False,
+) -> dict[str, Any]:
+    if count < 1 or count > 100:
+        raise HTTPException(status_code=400, detail="count must be between 1 and 100")
+    if horizon_hours < 6 or horizon_hours > 168:
+        raise HTTPException(status_code=400, detail="horizon_hours must be between 6 and 168")
+    if min_score < 0 or min_score > 100:
+        raise HTTPException(status_code=400, detail="min_score must be between 0 and 100")
+
+    orchestrator = get_single_match_orchestrator()
+    return await asyncio.to_thread(
+        orchestrator.get_reversal_watchlist,
+        count,
+        horizon_hours,
+        min_score,
+        top_leagues_only,
+    )
+
+
+# ─── ADMIN: Retrain Pipeline ─────────────────────────────────
+
+def _run_retrain_pipeline(markets: str | None, trials: int):
+    """Background function: extract data → train model → reload."""
+    global _retrain_state
+    ai_dir = os.path.dirname(os.path.abspath(__file__))
+    scripts_dir = os.path.join(ai_dir, "scripts")
+    python = os.path.join(ai_dir, "venv", "bin", "python3")
+    if not os.path.exists(python):
+        python = sys.executable  # fallback
+
+    try:
+        # Step 1: Extract training data
+        print("🔄 [RETRAIN] Step 1/3: Extracting training data...", flush=True)
+        result = subprocess.run(
+            [python, os.path.join(scripts_dir, "extract_training_data.py")],
+            capture_output=True, text=True, timeout=600, cwd=ai_dir,
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"Extract failed:\n{result.stderr[-500:]}")
+        print(f"✅ [RETRAIN] Extract done", flush=True)
+
+        # Step 2: Train V25 Pro
+        print("🔄 [RETRAIN] Step 2/3: Training V25 Pro model...", flush=True)
+        train_cmd = [python, os.path.join(scripts_dir, "train_v25_pro.py")]
+        if markets:
+            train_cmd += ["--markets", markets]
+        train_cmd += ["--trials", str(trials)]
+
+        result = subprocess.run(
+            train_cmd, capture_output=True, text=True, timeout=3600, cwd=ai_dir,
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"Training failed:\n{result.stderr[-500:]}")
+        print(f"✅ [RETRAIN] Training done", flush=True)
+
+        # Step 3: Reload models in memory
+        print("🔄 [RETRAIN] Step 3/3: Reloading models...", flush=True)
+        try:
+            orchestrator = get_single_match_orchestrator()
+            v25 = orchestrator._get_v25_predictor()
+            v25._loaded = False
+            v25.load_models()
+            print("✅ [RETRAIN] Models reloaded in memory", flush=True)
+        except Exception as reload_err:
+            print(f"⚠️ [RETRAIN] Hot reload failed (restart needed): {reload_err}", flush=True)
+
+        _retrain_state.update({
+            "running": False,
+            "last_completed": datetime.now().isoformat(),
+            "last_status": "success",
+            "last_error": None,
+        })
+        print("🎉 [RETRAIN] Pipeline complete!", flush=True)
+
+    except Exception as err:
+        _retrain_state.update({
+            "running": False,
+            "last_completed": datetime.now().isoformat(),
+            "last_status": "failed",
+            "last_error": str(err),
+        })
+        print(f"❌ [RETRAIN] Pipeline failed: {err}", flush=True)
+
+
+@app.post("/v1/admin/retrain")
+async def admin_retrain(request: RetrainRequest) -> dict[str, Any]:
+    """Trigger full retrain pipeline: extract → train → reload."""
+    if _retrain_state["running"]:
+        return {
+            "status": "already_running",
+            "message": f"Retrain in progress since {_retrain_state['last_started']}",
+        }
+
+    _retrain_state.update({
+        "running": True,
+        "last_started": datetime.now().isoformat(),
+        "last_status": "running",
+        "last_error": None,
+    })
+
+    # Run in background thread
+    import threading
+    thread = threading.Thread(
+        target=_run_retrain_pipeline,
+        args=(request.markets, request.trials or 50),
+        daemon=True,
+    )
+    thread.start()
+
+    return {
+        "status": "triggered",
+        "message": "Retrain pipeline started in background",
+        "reason": request.reason,
+        "markets": request.markets or "all",
+        "trials": request.trials or 50,
+    }
+
+
+@app.get("/v1/admin/retrain/status")
+async def admin_retrain_status() -> dict[str, Any]:
+    """Check retrain pipeline status."""
+    return {**_retrain_state}
+
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", "8000"))
+    uvicorn.run("main:app", host="0.0.0.0", port=port, reload=True)
@@ -0,0 +1,356 @@
+"""
+Basketball V25 Predictor Package
+=================================
+Loads trained XGBoost + LightGBM models for basketball market predictions:
+  - ML  (Money Line  — home / away win)
+  - Total (Over/Under total points)
+  - Spread (ATS home cover / away cover)
+
+Model files live in this directory:
+  xgb_basketball_v25_{market}.json  — XGBoost (primary)
+  lgb_basketball_v25_{market}.txt   — LightGBM (ensemble)
+  feature_cols.json                 — ordered feature list
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+# ── Constants ─────────────────────────────────────────────────────────────────
+_DIR = os.path.dirname(os.path.abspath(__file__))
+_MARKETS = ("ml", "total", "spread")
+
+
+# ── Output dataclass ──────────────────────────────────────────────────────────
+
+@dataclass
+class BasketballMatchPrediction:
+    """Complete basketball match prediction output."""
+
+    match_id: str
+    home_team_name: str
+    away_team_name: str
+    league_name: str = ""
+
+    # Money Line
+    ml_home_prob: float = 0.50
+    ml_away_prob: float = 0.50
+    ml_pick: str = ""
+    ml_confidence: float = 0.0
+
+    # Total (Over/Under)
+    total_line: float = 0.0
+    total_over_prob: float = 0.50
+    total_under_prob: float = 0.50
+    total_pick: str = ""
+    total_confidence: float = 0.0
+
+    # Spread (ATS)
+    spread_home_line: float = 0.0
+    spread_home_prob: float = 0.50
+    spread_away_prob: float = 0.50
+    spread_pick: str = ""
+    spread_confidence: float = 0.0
+
+    # Meta
+    model_version: str = "basketball_v25"
+    risk_level: str = "MEDIUM"
+    analysis_details: Dict[str, Any] = field(default_factory=dict)
+    market_board: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "match_id": self.match_id,
+            "home_team": self.home_team_name,
+            "away_team": self.away_team_name,
+            "league": self.league_name,
+            "model": self.model_version,
+            "risk_level": self.risk_level,
+            "ml": {
+                "home_prob": round(self.ml_home_prob * 100, 1),
+                "away_prob": round(self.ml_away_prob * 100, 1),
+                "pick": self.ml_pick,
+                "confidence": round(self.ml_confidence, 1),
+            },
+            "total": {
+                "line": self.total_line,
+                "over_prob": round(self.total_over_prob * 100, 1),
+                "under_prob": round(self.total_under_prob * 100, 1),
+                "pick": self.total_pick,
+                "confidence": round(self.total_confidence, 1),
+            },
+            "spread": {
+                "home_line": self.spread_home_line,
+                "home_prob": round(self.spread_home_prob * 100, 1),
+                "away_prob": round(self.spread_away_prob * 100, 1),
+                "pick": self.spread_pick,
+                "confidence": round(self.spread_confidence, 1),
+            },
+            "market_board": self.market_board,
+            "analysis_details": self.analysis_details,
+        }
+
+
+# ── Predictor ─────────────────────────────────────────────────────────────────
+
+class BasketballV25Predictor:
+    """
+    Ensemble basketball predictor using XGBoost + LightGBM models.
+
+    Markets:
+      - ml     → home/away win probability
+      - total  → over/under total points
+      - spread → home/away ATS cover
+    """
+
+    def __init__(self) -> None:
+        self.feature_cols: List[str] = self._load_feature_cols()
+        self.models: Dict[str, Any] = {}
+        self._load_models()
+        print(f"✅ BasketballV25Predictor ready ({len(self.models)} models loaded)")
+
+    # ── Setup ──────────────────────────────────────────────────────────────
+
+    def _load_feature_cols(self) -> List[str]:
+        path = os.path.join(_DIR, "feature_cols.json")
+        try:
+            with open(path, "r") as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"⚠️  [Basketball] Could not load feature_cols.json: {e}")
+            return []
+
+    def _load_models(self) -> None:
+        for market in _MARKETS:
+            xgb_path = os.path.join(_DIR, f"xgb_basketball_v25_{market}.json")
+            lgb_path = os.path.join(_DIR, f"lgb_basketball_v25_{market}.txt")
+
+            xgb_model = self._try_load_xgb(xgb_path, market)
+            lgb_model = self._try_load_lgb(lgb_path, market)
+
+            if xgb_model is not None or lgb_model is not None:
+                self.models[market] = {"xgb": xgb_model, "lgb": lgb_model}
+
+    def _try_load_xgb(self, path: str, market: str) -> Optional[Any]:
+        if not os.path.exists(path):
+            return None
+        try:
+            import xgboost as xgb  # type: ignore[import-not-found]
+            m = xgb.XGBClassifier()
+            m.load_model(path)
+            return m
+        except Exception as e:
+            print(f"⚠️  [Basketball] XGB {market} load failed: {e}")
+            return None
+
+    def _try_load_lgb(self, path: str, market: str) -> Optional[Any]:
+        if not os.path.exists(path):
+            return None
+        try:
+            import lightgbm as lgb  # type: ignore[import-not-found]
+            with open(path, "r", encoding="utf-8") as f:
+                model_str = f.read()
+            return lgb.Booster(model_str=model_str)
+        except Exception as e:
+            print(f"⚠️  [Basketball] LGB {market} load failed: {e}")
+            return None
+
+    # ── Inference ──────────────────────────────────────────────────────────
+
+    def _build_feature_row(self, odds_data: Dict[str, Any], **kwargs: Any) -> "Any":
+        """Build a single-row DataFrame aligned to training feature columns."""
+        import pandas as pd  # type: ignore[import-not-found]
+
+        row: Dict[str, float] = {}
+        for col in self.feature_cols:
+            row[col] = float(kwargs.get(col) or odds_data.get(col) or 0.0)
+
+        # Map common odds keys
+        row["ml_home_odds"] = float(odds_data.get("ml_h") or 0.0)
+        row["ml_away_odds"] = float(odds_data.get("ml_a") or 0.0)
+        row["total_line"] = float(odds_data.get("tot_line") or 0.0)
+        row["total_over_odds"] = float(odds_data.get("tot_o") or 0.0)
+        row["total_under_odds"] = float(odds_data.get("tot_u") or 0.0)
+        row["spread_home_line"] = float(odds_data.get("spread_home_line") or 0.0)
+        row["spread_home_odds"] = float(odds_data.get("spread_h") or 0.0)
+        row["spread_away_odds"] = float(odds_data.get("spread_a") or 0.0)
+
+        # Implied probabilities
+        def _imp(odd: float) -> float:
+            return (1.0 / odd) if odd > 1.01 else 0.5
+
+        ml_h = row["ml_home_odds"]
+        ml_a = row["ml_away_odds"]
+        if ml_h > 1.01 and ml_a > 1.01:
+            raw = _imp(ml_h) + _imp(ml_a)
+            row["implied_home"] = _imp(ml_h) / raw
+            row["implied_away"] = _imp(ml_a) / raw
+            row["odds_overround"] = raw - 1.0
+
+        tot_o = row["total_over_odds"]
+        tot_u = row["total_under_odds"]
+        if tot_o > 1.01 and tot_u > 1.01:
+            raw = _imp(tot_o) + _imp(tot_u)
+            row["implied_total_over"] = _imp(tot_o) / raw
+            row["implied_total_under"] = _imp(tot_u) / raw
+
+        sp_h = row["spread_home_odds"]
+        sp_a = row["spread_away_odds"]
+        if sp_h > 1.01 and sp_a > 1.01:
+            raw = _imp(sp_h) + _imp(sp_a)
+            row["implied_spread_home"] = _imp(sp_h) / raw
+            row["implied_spread_away"] = _imp(sp_a) / raw
+
+        return pd.DataFrame([row])
+
+    def _ensemble_predict(self, market: str, df: "Any") -> List[float]:
+        """Return [p_class0, p_class1] from XGB+LGB ensemble."""
+        models = self.models.get(market, {})
+        xgb_model = models.get("xgb")
+        lgb_model = models.get("lgb")
+
+        probs_list: List[List[float]] = []
+
+        if xgb_model is not None:
+            try:
+                p = xgb_model.predict_proba(df)
+                probs_list.append([float(p[0][0]), float(p[0][1])])
+            except Exception as e:
+                print(f"⚠️  [Basketball] XGB {market} inference failed: {e}")
+
+        if lgb_model is not None:
+            try:
+                p_raw = lgb_model.predict(df)
+                p1 = float(p_raw[0]) if len(p_raw.shape) == 1 else float(p_raw[0][1])
+                probs_list.append([1.0 - p1, p1])
+            except Exception as e:
+                print(f"⚠️  [Basketball] LGB {market} inference failed: {e}")
+
+        if not probs_list:
+            return [0.5, 0.5]
+
+        p0 = sum(p[0] for p in probs_list) / len(probs_list)
+        p1 = sum(p[1] for p in probs_list) / len(probs_list)
+        total = p0 + p1 or 1.0
+        return [p0 / total, p1 / total]
+
+    # ── Public API ─────────────────────────────────────────────────────────
+
+    def predict(
+        self,
+        match_id: str,
+        home_team_id: str,
+        away_team_id: str,
+        home_team_name: str = "",
+        away_team_name: str = "",
+        league_id: str = "",
+        league_name: str = "",
+        odds_data: Optional[Dict[str, Any]] = None,
+        sidelined_data: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> BasketballMatchPrediction:
+        odds = odds_data or {}
+        prediction = BasketballMatchPrediction(
+            match_id=match_id,
+            home_team_name=home_team_name,
+            away_team_name=away_team_name,
+            league_name=league_name,
+        )
+
+        # Sidelined impact
+        home_sl = int((sidelined_data or {}).get("homeTeam", {}).get("totalSidelined", 0) or 0)
+        away_sl = int((sidelined_data or {}).get("awayTeam", {}).get("totalSidelined", 0) or 0)
+        kwargs.setdefault("home_sidelined_count", float(home_sl))
+        kwargs.setdefault("away_sidelined_count", float(away_sl))
+        kwargs.setdefault("sidelined_diff", float(home_sl - away_sl))
+        kwargs.setdefault("missing_players_impact", float(home_sl + away_sl) / 10.0)
+
+        if not self.models:
+            print("⚠️  [Basketball] No models loaded — returning neutral defaults")
+            return prediction
+
+        try:
+            df = self._build_feature_row(odds, **kwargs)
+
+            # ── ML ──
+            ml_probs = self._ensemble_predict("ml", df)
+            prediction.ml_home_prob = ml_probs[0]
+            prediction.ml_away_prob = ml_probs[1]
+            prediction.ml_pick = "1" if ml_probs[0] >= ml_probs[1] else "2"
+            prediction.ml_confidence = max(ml_probs) * 100.0
+
+            # ── Total ──
+            prediction.total_line = float(odds.get("tot_line") or 0.0)
+            tot_probs = self._ensemble_predict("total", df)
+            prediction.total_over_prob = tot_probs[1]
+            prediction.total_under_prob = tot_probs[0]
+            total_line = prediction.total_line
+            prediction.total_pick = (
+                f"Over {total_line}" if tot_probs[1] >= tot_probs[0] else f"Under {total_line}"
+            )
+            prediction.total_confidence = max(tot_probs) * 100.0
+
+            # ── Spread ──
+            prediction.spread_home_line = float(odds.get("spread_home_line") or 0.0)
+            sp_probs = self._ensemble_predict("spread", df)
+            prediction.spread_home_prob = sp_probs[0]
+            prediction.spread_away_prob = sp_probs[1]
+            home_line = prediction.spread_home_line
+            away_line = -home_line
+            prediction.spread_pick = (
+                f"Home {home_line:+.1f}" if sp_probs[0] >= sp_probs[1] else f"Away {away_line:+.1f}"
+            )
+            prediction.spread_confidence = max(sp_probs) * 100.0
+
+            # Market board summary
+            prediction.market_board = {
+                "ML": {
+                    "1": f"{prediction.ml_home_prob * 100:.0f}%",
+                    "2": f"{prediction.ml_away_prob * 100:.0f}%",
+                },
+                "Totals": {
+                    f"Over {total_line}": f"{prediction.total_over_prob * 100:.0f}%",
+                    f"Under {total_line}": f"{prediction.total_under_prob * 100:.0f}%",
+                },
+                "Spread": {
+                    f"Home {home_line:+.1f}": f"{prediction.spread_home_prob * 100:.0f}%",
+                    f"Away {away_line:+.1f}": f"{prediction.spread_away_prob * 100:.0f}%",
+                },
+            }
+
+            # Risk
+            top_conf = max(prediction.ml_confidence, prediction.total_confidence, prediction.spread_confidence)
+            prediction.risk_level = "LOW" if top_conf >= 65 else "MEDIUM" if top_conf >= 55 else "HIGH"
+            prediction.analysis_details = {
+                "model_version": "basketball_v25",
+                "markets_predicted": list(self.models.keys()),
+                "ensemble_size": {m: sum(1 for k in v.values() if v[k] is not None) for m, v in self.models.items()},
+            }
+
+        except Exception as e:
+            print(f"⚠️  [Basketball] Prediction failed for {match_id}: {e}")
+
+        return prediction
+
+
+# ── Singleton factory ──────────────────────────────────────────────────────────
+
+_predictor: Optional[BasketballV25Predictor] = None
+
+
+def get_basketball_v25_predictor() -> BasketballV25Predictor:
+    """Return the singleton BasketballV25Predictor (lazy-loaded)."""
+    global _predictor
+    if _predictor is None:
+        _predictor = BasketballV25Predictor()
+    return _predictor
+
+
+__all__ = [
+    "BasketballMatchPrediction",
+    "BasketballV25Predictor",
+    "get_basketball_v25_predictor",
+]
@@ -0,0 +1,101 @@
+[
+  "home_overall_elo",
+  "away_overall_elo",
+  "elo_diff",
+  "home_home_elo",
+  "away_away_elo",
+  "home_form_elo",
+  "away_form_elo",
+  "home_form_score",
+  "away_form_score",
+  "form_score_diff",
+  "home_points_avg",
+  "away_points_avg",
+  "points_avg_diff",
+  "home_conceded_avg",
+  "away_conceded_avg",
+  "conceded_avg_diff",
+  "home_net_rating",
+  "away_net_rating",
+  "net_rating_diff",
+  "home_win_rate",
+  "away_win_rate",
+  "win_rate_diff",
+  "home_winning_streak",
+  "away_winning_streak",
+  "streak_diff",
+  "home_rest_days",
+  "away_rest_days",
+  "rest_diff",
+  "home_rebounds_avg",
+  "away_rebounds_avg",
+  "rebounds_diff",
+  "home_assists_avg",
+  "away_assists_avg",
+  "assists_diff",
+  "home_steals_avg",
+  "away_steals_avg",
+  "steals_diff",
+  "home_blocks_avg",
+  "away_blocks_avg",
+  "blocks_diff",
+  "home_turnovers_avg",
+  "away_turnovers_avg",
+  "turnovers_diff",
+  "home_fg_pct",
+  "away_fg_pct",
+  "fg_pct_diff",
+  "home_three_pt_pct",
+  "away_three_pt_pct",
+  "three_pt_pct_diff",
+  "home_ft_pct",
+  "away_ft_pct",
+  "ft_pct_diff",
+  "home_q1_avg",
+  "away_q1_avg",
+  "home_q4_avg",
+  "away_q4_avg",
+  "home_conc_rebounds_avg",
+  "away_conc_rebounds_avg",
+  "home_conc_assists_avg",
+  "away_conc_assists_avg",
+  "home_conc_turnovers_avg",
+  "away_conc_turnovers_avg",
+  "home_conc_fg_pct",
+  "away_conc_fg_pct",
+  "home_conc_three_pt_pct",
+  "away_conc_three_pt_pct",
+  "h2h_total_matches",
+  "h2h_home_win_rate",
+  "h2h_avg_points",
+  "h2h_avg_margin",
+  "h2h_over_total_rate",
+  "h2h_home_cover_rate",
+  "league_avg_points",
+  "league_home_win_rate",
+  "league_over_total_rate",
+  "league_home_cover_rate",
+  "ml_home_odds",
+  "ml_away_odds",
+  "implied_home",
+  "implied_away",
+  "total_line",
+  "total_over_odds",
+  "total_under_odds",
+  "implied_total_over",
+  "implied_total_under",
+  "spread_home_line",
+  "spread_home_odds",
+  "spread_away_odds",
+  "implied_spread_home",
+  "implied_spread_away",
+  "odds_overround",
+  "home_sidelined_count",
+  "away_sidelined_count",
+  "sidelined_diff",
+  "missing_players_impact",
+  "total_points_form",
+  "total_points_allowed_form",
+  "projected_total_delta_vs_line",
+  "projected_margin_vs_spread"
+]
@@ -0,0 +1,655 @@
+tree
+version=v4
+num_class=1
+num_tree_per_iteration=1
+label_index=0
+max_feature_idx=98
+objective=binary sigmoid:1
+feature_names=Column_0 Column_1 Column_2 Column_3 Column_4 Column_5 Column_6 Column_7 Column_8 Column_9 Column_10 Column_11 Column_12 Column_13 Column_14 Column_15 Column_16 Column_17 Column_18 Column_19 Column_20 Column_21 Column_22 Column_23 Column_24 Column_25 Column_26 Column_27 Column_28 Column_29 Column_30 Column_31 Column_32 Column_33 Column_34 Column_35 Column_36 Column_37 Column_38 Column_39 Column_40 Column_41 Column_42 Column_43 Column_44 Column_45 Column_46 Column_47 Column_48 Column_49 Column_50 Column_51 Column_52 Column_53 Column_54 Column_55 Column_56 Column_57 Column_58 Column_59 Column_60 Column_61 Column_62 Column_63 Column_64 Column_65 Column_66 Column_67 Column_68 Column_69 Column_70 Column_71 Column_72 Column_73 Column_74 Column_75 Column_76 Column_77 Column_78 Column_79 Column_80 Column_81 Column_82 Column_83 Column_84 Column_85 Column_86 Column_87 Column_88 Column_89 Column_90 Column_91 Column_92 Column_93 Column_94 Column_95 Column_96 Column_97 Column_98
+feature_infos=none none none none none none none [0:100] [0:100] [-100:100] [54:128.875] [61:138] [-41.333333333333329:24] [61:130.125] [59:133] [-50:34.916666666666671] [-28.666666666666657:32.5] [-24.5:27] [-35.5:31.833333333333329] [0:1] [0:1] [-1:1] [0:12] [0:12] [-12:10] [0.91666666666666663:186.1875] [0.85416666666666663:185.08333333333337] [-179.02083333333334:184.16666666666663] [20:54] [22:56] [-21:15.833333333333332] [11:34.5] [9:36] [-15:13.333333333333332] [2:13] [3:13] [-8:5.5] [0.875:9] [0:12] [-9:4.875] [7:22] [8:23] [-10:10] [0.41025641025641019:0.67647058823529416] [0.39730639730639727:0.76744186046511631] [-0.3174418604651163:0.22647058823529409] [0.20419254658385089:0.4825000000000001] [0.1875:0.54166666666666663] [-0.22171945701357459:0.17923280423280419] [0.47826086956521741:0.87898457080200498] [0.42857142857142849:0.88636363636363635] [-0.29647435897435898:0.38962801311591622] [11:39.666666666666664] [15.5:40] [10:31.875] [11.5:34] [15:56] [17:57] [12:32.125] [10:38] [8:20] [7:22] [0.40000000000000002:0.69047619047619047] [0.3902439024390244:0.71739130434782605] [0.23753976670201479:0.51851851851851849] [0.1707317073170731:0.54545454545454541] [0:8] [0:1] [120:295] [-38:36] [0:1] [0:1] [140.39130434782609:233.09999999999999] [0:1] [0:1] [0:1] [1.05:4.1100000000000003] [1.05:4.1299999999999999] [0.2034883720930232:0.79729729729729726] [0.20270270270270269:0.79651162790697683] [145.5:257.5] [1.3:7.7599999999999998] [1.4099999999999999:7.5599999999999996] [0.1789976133651551:0.75977653631284914] [0.24022346368715081:0.82100238663484482] [-15.5:12.5] [1.3:2.7200000000000002] [1.1799999999999999:2.7799999999999998] [0.36298076923076922:0.64953271028037374] [0.35046728971962621:0.63701923076923073] [0.1918833727344364:0.21555133935749429] none none none none [132:250.6875] [126.25:256.625] [-63.5:88.6875] [-35.5:27.5]
+tree_sizes=2312 2651 2758 2331 2348 2534 2554 2662 2359 2770 1932 1926 2552 2145 2460 2555 1931 2453 1831 2020 2352 2348 2035
+
+Tree=0
+num_leaves=21
+num_cat=0
+split_feature=77 77 95 50 40 97 37 25 73 56 81 57 35 17 50 97 25 23 23 9
+split_gain=87.208 23.2965 12.6569 10.5307 10.1901 9.83622 9.59439 7.56522 7.2843 6.81795 6.60435 5.65211 7.74871 6.22559 5.61137 5.14301 3.28504 2.92219 2.6911 0.0931822
+threshold=1.3750000000000002 2.6550000000000007 166.34375000000003 0.73851279305095374 11.062500000000002 5.9687500000000009 3.7750000000000004 1.8802083333333337 0.5344873150105709 30.803571428571434 1.5750000000000004 41.062500000000007 6.6937500000000005 -4.7749999999999977 0.71663103786665172 -3.4241071428571384 7.7864583333333348 1.0000000180025095e-35 1.0000000180025095e-35 -39.015151515151508
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=3 2 14 -1 -4 7 -7 -6 -3 -10 -5 12 -11 -13 -2 -16 18 -17 -12 -20
+right_child=1 8 4 10 5 6 -8 -9 9 11 16 13 -14 -15 15 17 -18 -19 19 -21
+leaf_value=-0.14765628269715012 -0.15600540791535678 -0.23353299922727577 -0.12151989070972055 -0.13344020462290634 -0.11780070546597361 -0.21612555668738542 -0.16327023115717296 -0.15881183656013212 -0.15004174704520915 -0.17986005139594724 -0.10382337530156519 -0.2025678370168939 -0.21889492254600434 -0.15072330828751174 -0.17027559642606713 -0.19596193574534582 -0.1164283857771044 -0.23353299922727577 -0.079223274212206221 -0.072514155733290175
+leaf_weight=11.17881618440151 6.70728971064091 6.210453435778617 11.427234321832655 9.1914710849523527 7.94938039779663 9.1914710849523562 13.662997558712958 76.015950053930283 6.7072897106409064 14.159833833575247 8.943052947521215 6.4588715732097617 19.128196582198143 8.6946348100900632 6.9557078480720582 7.4525441229343361 8.1977985352277738 5.9620352983474731 5.9620352983474714 7.4525441229343414
+leaf_count=45 27 25 46 37 32 37 55 306 27 57 36 26 77 35 28 30 33 24 24 30
+internal_value=-0.160244 -0.171796 -0.16307 -0.113358 -0.157421 -0.161262 -0.184527 -0.154929 -0.192463 -0.187838 -0.103712 -0.193072 -0.202291 -0.172821 -0.187739 -0.198187 -0.0947688 -0.21266 -0.0868269 -0.075496
+internal_weight=257.61 206.684 145.325 50.9257 118.247 106.82 22.8545 83.9653 61.3593 55.1488 39.7469 48.4415 33.288 15.1535 27.0776 20.3703 30.5554 13.4146 22.3576 13.4146
+internal_count=1037 832 585 205 476 430 92 338 247 222 160 195 134 61 109 82 123 54 90 54
+is_linear=0
+shrinkage=1
+
+
+Tree=1
+num_leaves=24
+num_cat=0
+split_feature=78 78 95 46 40 97 37 41 13 50 75 83 22 17 50 97 15 81 65 43 23 43 25
+split_gain=80.2042 21.5716 11.6989 11.0897 9.36546 9.08525 8.91556 8.1723 7.75226 7.09679 6.96929 6.56155 6.17385 5.70382 5.20301 4.788 4.74542 3.71513 3.26193 3.12932 2.73996 1.35961 0.11562
+threshold=0.39285714285714285 0.68693349935065817 166.34375000000003 0.34153389001132711 11.062500000000002 5.9687500000000009 3.7750000000000004 14.612500000000002 109.93750000000001 0.74692579813599125 0.36503968253968255 0.47970222696600762 1.5000000000000002 6.5625000000000009 0.71663103786665172 -3.4241071428571384 1.5166666666666659 1.635 0.35759117986701622 0.52557970719916269 1.0000000180025095e-35 0.51924929840975398 3.0312500000000004
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=3 2 14 8 -4 7 -7 -6 9 -1 16 -12 17 21 -2 -16 18 -13 -3 -20 -17 22 -5
+right_child=1 10 4 13 5 6 -8 -9 -10 -11 11 12 -14 -15 15 20 -18 -19 19 -21 -22 -23 -24
+leaf_value=0.0055530680640734674 0.0032845293651423612 -0.072766645625454485 0.036292826760507588 0.077436849336701308 -0.0022894176915147862 -0.054725292524358454 -0.003689958048423233 0.027881485430822688 -0.013760354637319356 0.059619560028970849 -0.050594773409676115 -0.0085801885492360844 -0.033840627756109222 0.036366913393967221 -0.010423432121785391 -0.035188847843671808 -0.021864921616209863 0.033823144597002808 -0.060759072260146665 -0.021284474578964662 -0.071669256311519158 0.058239915950701049 0.085149025961743521
+leaf_weight=6.4684473276138368 6.7090961784124401 9.4034554809331912 11.457648575305937 5.9847112745046669 65.60038697719574 9.142817825078966 13.658771887421606 18.391589343547821 6.4761682301759711 9.7236045598983747 7.1794854700565365 7.4327530264854449 8.1723358631134015 9.9696762263774854 6.9495052695274415 7.4284560978412575 10.15483947098255 5.9542565494775772 6.6812664419412595 6.190190851688385 5.9189314842224121 5.978186532855033 6.4756923913955688
+leaf_count=26 27 38 46 24 264 37 55 74 26 39 29 30 33 40 28 30 41 24 27 25 24 24 26
+internal_value=-0.000786037 -0.0118905 -0.00349945 0.0440926 0.00192543 -0.00176177 -0.0241537 0.00431706 0.0232273 0.0380209 -0.0318166 -0.0174741 -0.00644452 0.0607419 -0.0272534 -0.0373477 -0.0445269 0.0102799 -0.0548581 -0.0417748 -0.0513662 0.0739213 0.0814449
+internal_weight=257.502 206.426 145.257 51.0765 118.251 106.794 22.8016 83.992 22.6682 16.1921 61.1686 28.7388 21.5593 28.4083 27.006 20.2969 32.4298 13.387 22.2749 12.8715 13.3474 18.4386 12.4604
+internal_count=1037 832 585 205 476 430 92 338 91 65 247 116 87 114 109 82 131 54 90 52 54 74 50
+is_linear=0
+shrinkage=0.04
+
+
+Tree=2
+num_leaves=25
+num_cat=0
+split_feature=77 76 10 46 51 75 75 42 12 51 74 44 9 61 86 41 49 17 85 44 27 49 74 97
+split_gain=73.8475 19.9927 10.9898 10.1665 9.79528 8.50828 11.1493 9.23472 9.00307 8.63936 8.14649 7.11143 7.43675 10.0884 8.56935 6.6516 6.48284 5.22574 5.21615 4.45089 3.01631 2.88722 1.39723 0.105613
+threshold=1.3750000000000002 1.2250000000000003 80.937500000000014 0.34153389001132711 0.011242161620033652 0.44508064516129037 0.39517441860465125 -0.61249999999999971 2.5499999999999976 0.012462680598456451 0.40642170329670335 0.55897334407178179 8.7121212121212164 11.866071428571431 1.635 14.225000000000001 0.78414366883116904 6.5625000000000009 6.0000000000000009 0.51258507460016867 -0.10937499999999993 0.73610958414604988 0.62250000000000016 1.1937499999999945
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=3 11 19 4 18 6 8 10 -4 -9 -7 12 13 -2 -15 20 -8 22 -1 -3 -14 -21 23 -5
+right_child=1 2 5 17 -6 7 16 9 -10 -11 -12 -13 15 14 -16 -17 -18 -19 -20 21 -22 -23 -24 -25
+leaf_value=0.017705783755189462 0.028974497745101052 -0.0060737041061852126 0.028384924190391733 0.081917709440956332 -0.011007695119626166 0.051971315475459197 -0.05418693058345065 -0.015490981812325239 -0.030486429608756988 0.017134873390643509 0.01007092726093781 -0.071582917658417497 -0.024872499607636107 0.0039725729814389819 -0.046514665309970234 -0.0035756501646253529 -0.0037995538175229883 0.034855017993211231 0.06661466771004268 -0.026672382631287159 -0.057894168683677763 -0.065766238281201289 0.054894232678188361 0.074556160849369266
+leaf_weight=6.7373062372207659 7.4330984354019192 7.1768550276756313 11.678280815482141 6.4950603991746956 8.7123459726572019 11.683709740638731 11.923531427979471 30.992172449827194 6.4527826756238928 22.351678267121315 20.364999443292618 5.9138691127300254 5.9248394817113939 9.3952521085739154 12.583362787961958 6.4179672747850409 6.2149500101804724 9.9856856316328031 7.2363171875476837 6.1660670638084394 17.493629351258278 5.9290464669466019 5.9967442750930777 5.9974743723869324
+leaf_count=27 30 29 47 26 35 47 48 125 26 90 82 24 24 38 51 26 25 40 29 25 71 24 24 24
+internal_value=-0.000757575 -0.0114353 -0.00296399 0.0422564 0.0222795 0.00148162 -0.0147493 0.00837551 0.00743281 -0.00182038 0.0253462 -0.0297572 -0.0255824 -0.011309 -0.0249328 -0.0396526 -0.0369223 0.058172 0.0430335 -0.0310287 -0.0495397 -0.0458363 0.0707651 0.0783835
+internal_weight=257.257 206.096 140.934 51.1609 22.686 121.662 36.2695 85.3926 18.1311 53.3439 32.0487 65.162 59.2481 29.4117 21.9786 29.8364 18.1385 28.475 13.9736 19.272 23.4185 12.0951 18.4893 12.4925
+internal_count=1037 832 568 205 91 490 146 344 73 215 129 264 240 119 89 121 73 114 56 78 95 49 74 50
+is_linear=0
+shrinkage=0.04
+
+
+Tree=3
+num_leaves=21
+num_cat=0
+split_feature=77 77 95 46 51 86 49 42 73 69 54 7 31 85 50 81 61 44 53 77
+split_gain=68.0698 18.5538 10.4158 9.36539 9.01462 7.14355 8.22377 7.01134 6.54248 6.34821 10.3019 8.78745 4.815 4.79475 4.79 3.98009 3.96113 2.92643 3.60798 2.21945
+threshold=1.3750000000000002 2.6550000000000007 166.34375000000003 0.34153389001132711 0.011242161620033652 2.2450000000000006 0.80827483213138251 -0.61249999999999971 0.5344873150105709 4.6500000000000012 23.062500000000004 40.833333333333343 23.550000000000004 6.0000000000000009 0.71663103786665172 1.7750000000000001 12.062500000000002 0.53723539037745083 24.803571428571434 1.925
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=3 2 14 4 13 6 7 -4 -3 11 -11 -10 -8 -1 -2 19 -13 18 -5 -16
+right_child=1 8 5 17 -6 -7 12 -9 9 10 -12 16 -14 -15 15 -17 -18 -19 -20 -21
+leaf_value=0.016987942399224069 0.0035814571364199662 -0.068907535589063609 0.01429912015371851 0.079098125792394905 -0.010575188509827679 -0.033022257030977734 0.059900457392998388 -0.008250813675967944 0.00010937594628987166 -0.040766144429216389 0.025542986379799158 -0.019382488279346841 0.013986965287345072 0.063856791784991249 -0.032605400222488659 -0.0094169329033003141 -0.05275351833756161 0.039347381597312048 0.041332957240490006 -0.064822733951046208
+leaf_weight=6.7410361915826815 6.703504994511607 6.0858818590641013 35.323686808347702 11.494772866368299 8.7060475498437864 8.6918699741363508 5.9581677168607703 58.758967056870461 9.3814801126718503 6.6312184035778037 8.6243968755006772 7.6371410340070751 9.4523572921752912 7.2466183453798294 7.3598874658346194 6.4097239673137656 22.335135906934738 10.743333801627157 6.2475921660661689 6.3931281566619873
+leaf_count=27 27 25 142 46 35 35 24 237 38 27 35 31 38 29 30 26 91 43 25 26
+internal_value=-0.000730438 -0.0109991 -0.00322902 0.0405507 0.0213801 0.00188154 0.0046523 0.000215644 -0.0295683 -0.0251842 -0.00327986 -0.0336755 0.0317385 0.0412694 -0.0257105 -0.0354492 -0.0442504 0.0558234 0.0657999 -0.0475817
+internal_weight=256.926 205.747 145.051 51.1794 22.6937 118.185 109.493 94.0827 60.6953 54.6094 15.2556 39.3538 15.4105 13.9877 26.8662 20.1627 29.9723 28.4857 17.7424 13.753
+internal_count=1037 832 585 205 91 476 441 379 247 222 62 160 62 56 109 82 122 114 71 56
+is_linear=0
+shrinkage=0.04
+
+
+Tree=4
+num_leaves=21
+num_cat=0
+split_feature=77 76 10 46 38 52 90 13 63 35 27 50 50 12 36 17 44 49 74 45
+split_gain=62.8093 17.2545 9.84388 8.65527 8.50818 8.94286 7.35721 7.1083 6.79729 7.71767 6.73811 6.55324 5.90783 5.04228 9.19595 4.75428 4.11592 2.77884 1.29074 0.102719
+threshold=1.3750000000000002 1.2250000000000003 80.937500000000014 0.34153389001132711 2.6904761904761911 26.562500000000004 0.19724305626860048 109.93750000000001 0.55212996425566885 6.2750000000000012 -0.020833333333333648 0.76335870360422431 0.74692579813599125 7.3125000000000009 -0.26190476190476181 6.5625000000000009 0.51258507460016867 0.73610958414604988 0.62250000000000016 -0.0013187490579748998
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=3 8 16 7 11 6 -6 12 9 -2 -7 -4 -1 14 -11 18 -3 -18 19 -5
+right_child=1 2 4 15 5 10 -8 -9 -10 13 -12 -13 -14 -15 -16 -17 17 -19 -20 -21
+leaf_value=0.0050560182108375287 0.01454555314741844 -0.0053774531433530308 0.0088078452630964664 0.076512274772428487 0.012372105311854016 0.04280070757761658 -0.015898578376521092 -0.014892135795344198 -0.057603106440945573 -0.013716056812372755 -2.743210612548636e-05 0.06049972094546327 0.054367671817810027 -0.0053464224261316716 -0.054858503781032956 0.031440123411904081 -0.024849777283710722 -0.063361316106082435 0.050431436557637821 0.069244124813442359
+leaf_weight=6.4694478660821977 7.8782515972852698 7.1609281748533276 10.659276410937311 6.4840846359729793 19.36934831738472 10.460701778531076 61.473121464252472 6.4756214618682852 10.231325536966322 16.168815225362774 13.415295347571371 6.2101935893297187 9.7394945174455625 11.545304596424101 18.798230275511745 9.9960098117589933 6.1246920526027662 5.871805265545845 5.9897889196872702 5.9808590859174755
+leaf_count=26 32 29 43 26 78 42 248 26 42 66 54 25 39 47 77 40 25 24 24 24
+internal_value=-0.0007041 -0.010581 -0.00272469 0.0389631 0.00147434 -0.00277256 -0.0091251 0.0205332 -0.0276919 -0.0220654 0.0187367 0.0278373 0.034686 -0.0282665 -0.0358342 0.0536577 -0.029375 -0.0436996 0.0656918 0.0730249
+internal_weight=256.503 205.367 140.745 51.1353 121.588 104.718 80.8425 22.6846 64.6219 54.3906 23.876 16.8695 16.2089 46.5124 34.967 28.4507 19.1574 11.9965 18.4547 12.4649
+internal_count=1037 832 568 205 490 422 326 91 264 222 96 68 65 190 143 114 78 49 74 50
+is_linear=0
+shrinkage=0.04
+
+
+Tree=5
+num_leaves=23
+num_cat=0
+split_feature=77 77 49 8 59 55 59 9 40 35 50 74 36 58 97 86 49 8 95 56 52 48
+split_gain=59.2137 16.5141 9.9144 11.7486 12.1383 8.99339 10.5611 8.66857 10.2694 8.14362 7.72674 7.72484 12.0149 7.4839 7.07919 6.69422 4.48655 4.69909 4.36454 2.6211 3.68984 2.53359
+threshold=1.3550000000000002 2.2550000000000003 0.75657876131221735 31.666666666666668 17.267857142857146 19.535714285714288 18.937500000000004 -2.6785714285714266 12.937500000000002 8.3875000000000011 0.73851279305095374 0.54575358851674649 0.066964285714285574 24.354166666666668 2.9821428571428616 1.7450000000000003 0.77175549922512843 65.151515151515156 173.36607142857147 40.38750000000001 20.937500000000004 0.0091659973707001029
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=10 2 3 -2 -5 -3 18 8 -8 11 -1 14 -13 -6 -4 -9 19 -18 21 20 -12 -7
+right_child=1 5 9 4 13 6 7 15 -10 -11 16 12 -14 -15 -16 -17 17 -19 -20 -21 -22 -23
+leaf_value=0.011681667207113649 0.033908823443212138 0.017536154054844273 0.021215365730383975 0.03251466321515277 -0.035698618619601191 -0.069217953298740698 0.040352083533208016 -0.037782244586161744 -0.02378355379185353 -0.016829989475423059 0.067034861961705272 0.039469073342078345 -0.028155083253979179 0.009683122942141572 0.064205028012414941 -0.003245990990143062 0.008774257662963655 0.054818660291170745 -0.016792700372560584 0.076628087701740399 0.026483773237715093 -0.038854738339966714
+leaf_weight=10.698686346411703 8.1725911200046522 9.060679689049719 26.58554495871067 6.4189013689756385 30.358332172036171 10.46654355525971 8.4112317115068453 24.458471849560738 7.6072484105825415 11.665961533784865 8.4696357846260089 6.9492753297090557 10.640220895409582 7.1914227455854407 7.9649787694215766 14.189488068222998 6.9667989164590818 7.2231719940900803 5.8842895776033393 9.7066867947578412 6.2319085150957099 7.58248247206211
+leaf_count=43 33 37 107 26 123 43 34 100 31 47 34 28 43 29 32 58 28 29 24 39 25 31
+internal_value=0.0024258 -0.0070979 0.00280729 -0.0101318 -0.0183177 -0.0201993 -0.0245493 -0.0148477 0.00989378 0.0133809 0.0417609 0.0201404 -0.00143807 -0.0270072 0.0311258 -0.0251024 0.0500983 0.0322124 -0.046709 0.0604964 0.0498455 -0.0564622
+internal_weight=252.905 203.608 115.947 52.1412 43.9687 87.6604 78.5998 54.6664 16.0185 63.806 49.2969 52.14 17.5895 37.5498 34.5505 38.648 38.5982 14.19 23.9333 24.4082 14.7015 18.049
+internal_count=1024 826 468 211 178 358 321 223 65 257 198 210 71 152 139 158 155 57 98 98 59 74
+is_linear=0
+shrinkage=0.04
+
+
+Tree=6
+num_leaves=23
+num_cat=0
+split_feature=76 78 27 46 86 11 55 29 65 47 50 46 18 61 81 36 44 9 13 43 81 44
+split_gain=54.7148 15.7289 10.7788 14.3867 9.58583 8.78499 8.46201 10.8596 9.81775 8.03411 7.677 7.45074 5.6669 7.59424 5.03116 4.82371 4.8014 4.00902 3.45566 2.28622 3.41567 0.00497756
+threshold=2.1950000000000007 0.62900904125363766 -2.3020833333333326 0.34016393531964906 2.1450000000000005 122.43750000000001 19.854166666666668 39.812500000000007 0.3770676732818225 0.36593380560885896 0.73563272044162131 0.35736791305409527 -3.1874999999999996 12.690476190476192 1.5150000000000003 0.25833333333333336 0.49644821746513607 -8.7121212121212164 117.43750000000001 0.50247426971013531 1.7450000000000003 0.53567202664757096
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 2 11 9 5 -5 -3 8 17 16 -2 15 -9 -14 -12 -1 -4 -8 19 21 -21 -16
+right_child=10 6 3 4 -6 -7 7 12 -10 -11 14 -13 13 -15 18 -17 -18 -19 -20 20 -22 -23
+leaf_value=0.070324761157363386 0.0084031851759769002 0.012486475233554927 -0.014274497772434848 0.02062654133633882 -0.032240672579085888 -0.029937743516828159 -0.020241102484534694 0.022406478756216045 0.0013966323082333749 0.0049975598343196606 0.016976514726108942 -0.0032581054169875008 0.011631640379196602 -0.033623046124736253 0.073425640497252462 0.021730508558563181 -0.050815423135628625 -0.053986984893246243 0.028244335395794146 0.069298036861864615 0.028035945730723436 0.075014904249462944
+leaf_weight=6.9250844269990939 9.2112289071083051 11.516124725341795 9.6139747798442858 48.390351086854935 7.907471075654029 6.2022370845079413 7.0930576324462846 7.9190109968185416 8.3109913170337659 11.12387755513191 6.4693672657012931 7.1976774334907523 9.5812086164951342 15.581949874758719 6.6890226900577598 6.1896365433931351 14.328032165765761 27.358511343598369 5.9492755085229865 6.9541786164045316 5.9617312103509903 5.9650087505578995
+leaf_count=28 37 47 39 195 32 25 29 32 34 45 26 29 39 64 27 25 58 113 24 28 24 24
+internal_value=0.00233149 -0.00659898 0.00293381 -0.00258517 0.00892003 0.014882 -0.0194618 -0.0243128 -0.0376256 -0.0230916 0.0411639 0.029443 -0.00710444 -0.0163917 0.0491075 0.0473902 -0.0361423 -0.0470392 0.0557024 0.062091 0.0502523 0.0741748
+internal_weight=252.439 205.239 117.878 97.5659 62.5001 54.5926 87.3609 75.8447 42.7626 35.0659 47.1998 20.3124 33.0822 25.1632 37.9886 13.1147 23.942 34.4516 31.5192 25.5699 12.9159 12.654
+internal_count=1024 834 476 394 252 220 358 311 176 142 190 82 135 103 153 53 97 142 127 103 52 51
+is_linear=0
+shrinkage=0.04
+
+
+Tree=7
+num_leaves=24
+num_cat=0
+split_feature=76 78 27 31 32 42 58 74 15 40 46 26 76 97 98 73 62 60 46 61 90 97 42
+split_gain=50.8947 11.0049 9.32122 10.5702 10.4712 9.27532 8.02666 7.19583 7.79066 6.93078 7.78095 6.76995 6.46148 6.98083 6.77168 6.35566 6.68601 5.47664 5.22172 4.56413 4.30903 3.83111 0.826657
+threshold=1.8750000000000002 0.70062845714719713 -9.1770833333333304 18.401785714285719 20.645833333333339 -2.774999999999999 26.401785714285719 0.63245614035087727 -0.43749999999999994 11.866071428571431 0.37542254586435625 6.7812500000000009 2.4650000000000003 -3.4241071428571384 -6.3184523809523787 0.55383792139841859 0.51117533329139231 13.35416666666667 0.35034659555724629 12.062500000000002 0.19829454556786633 0.28125000000000006 0.19761904761904778
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 2 -1 7 11 -6 12 8 -4 19 15 -5 14 -14 -2 -11 -17 18 -16 -3 -15 -19 -22
+right_child=6 9 3 4 5 -7 -8 -9 -10 10 -12 -13 13 20 17 16 -18 21 -20 -21 22 -23 -24
+leaf_value=0.036083213444415528 0.053277627847354556 -0.021782130288108433 -0.0091325820237097618 0.049355787080620245 0.039957936624339677 -0.010162507947377566 0.066494523434590488 0.007861663962773149 -0.056001702923737531 -0.05035447873268746 0.025153534242404262 -0.0002279551315397668 0.0074196720389386114 0.025979484890861368 -0.0040180493742294409 -0.035722871972219031 0.012557904583466907 -0.037148801270085199 0.040822377329808285 -0.065566429091563946 0.054687788523123476 0.0082770984108304652 0.074704189299082305
+leaf_weight=9.12299896776676 5.9481788575649253 6.5940756052732459 9.5768276453018242 10.393245324492456 6.4848928600549689 66.375781863927841 8.9054767787456495 7.6045115441083899 13.925430610775946 9.6051787436008471 6.321256920695304 7.647834599018096 7.4389976263046291 6.437974855303767 7.4326431751251283 8.6875483840703982 9.7281266301870328 5.9339717775583249 9.4233583807945234 9.0198750644922239 5.9406516849994642 5.9482765197753906 7.4301211833953857
+leaf_count=37 24 27 39 42 26 268 36 31 57 40 26 31 30 26 30 36 40 24 38 38 24 24 30
+internal_value=0.00224138 -0.00900344 -0.00291719 -0.00583339 0.00105391 -0.00570159 0.0309866 -0.0259598 -0.0369032 -0.0249795 -0.0149333 0.0283366 0.0258809 0.0404581 0.0144298 -0.0239765 -0.0102184 0.00638917 0.02105 -0.0470755 0.0528654 -0.0144085 0.0658109
+internal_weight=251.927 181.088 131.132 122.009 90.9018 72.8607 70.8397 31.1068 23.5023 49.9561 34.3421 18.0411 61.9342 27.2477 34.6864 28.0209 18.4157 28.7382 16.856 15.614 19.8087 11.8822 13.3708
+internal_count=1024 738 531 494 367 294 286 127 96 207 142 73 250 110 140 116 76 116 68 65 80 48 54
+is_linear=0
+shrinkage=0.04
+
+
+Tree=8
+num_leaves=21
+num_cat=0
+split_feature=76 78 27 10 18 88 65 58 48 76 75 50 55 57 45 61 52 16 37 64
+split_gain=47.0285 10.2297 8.57167 9.90629 8.49863 11.7596 8.93582 7.47628 6.70549 7.3988 6.88535 6.62498 6.53575 6.19036 7.25158 6.45563 5.31391 3.33594 2.78119 2.27511
+threshold=1.8750000000000002 0.70062845714719713 -9.1770833333333304 82.267857142857153 -4.3541666666666705 0.49939467312348679 0.34321545037197632 26.401785714285719 0.021174040484134952 2.2250000000000005 0.64837092731829593 0.73563272044162131 19.854166666666668 41.062500000000007 0.0031867569273384007 12.062500000000002 20.937500000000004 -6.3124999999999991 2.6125000000000003 0.36408812715877942
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 2 -1 17 5 -5 -6 8 9 10 -2 -11 -3 15 -15 -14 -13 -4 -19 -17
+right_child=7 12 3 4 6 -7 -8 -9 -10 11 -12 16 13 14 -16 19 -18 18 -20 -21
+leaf_value=0.034533388049788116 0.023208498381564548 0.010691617096435792 -0.0099350499244745989 -0.013374654384074001 -0.030791758397498405 0.036260912427308507 0.00098553848763632086 0.064191286864412847 0.055107303489570873 -0.0011209989712481605 -0.023658767436963126 0.066673274412926392 -0.0085936349487782514 0.018687811460451158 -0.034036012019189175 -0.064822499725983529 0.027488397354637369 -0.062556001891513391 -0.025921626974491768 -0.035460654646497967
+leaf_weight=9.1505375951528531 10.182640746235849 7.3519092053174964 8.031925320625307 12.611105665564539 19.997042715549469 19.363006785511971 48.494191810488701 8.8569523096084577 9.8766392171382886 7.7215904891490963 9.8834861069917661 8.600008040666582 6.5588535666465786 7.2764098048210171 9.7889975756406766 12.264306232333185 15.548548832535742 6.0707129538059217 7.3061331808567047 6.4392972588539115
+leaf_count=37 41 30 33 51 81 78 196 36 40 31 40 35 27 30 41 52 63 25 30 27
+internal_value=0.00215494 -0.00866469 -0.0028044 -0.00560779 -0.000343403 0.0166838 -0.00829232 0.029821 0.0248962 0.019151 0.000124224 0.0311307 -0.0241206 -0.0301671 -0.0115554 -0.0427397 0.0414433 -0.0303121 -0.0425471 -0.0547138
+internal_weight=251.374 180.704 131.025 121.874 100.465 31.9741 68.4912 70.6699 61.8129 51.9363 20.0661 31.8701 49.6798 42.3279 17.0654 25.2625 24.1486 21.4088 13.3768 18.7036
+internal_count=1024 738 531 494 406 129 277 286 250 210 81 129 207 177 71 106 98 88 55 79
+is_linear=0
+shrinkage=0.04
+
+
+Tree=9
+num_leaves=25
+num_cat=0
+split_feature=78 78 49 49 88 63 41 34 8 52 58 40 46 48 78 75 50 73 62 52 52 89 61 30
+split_gain=43.4968 9.51409 8.12139 9.24718 9.16177 10.1476 7.62239 8.2415 7.26498 6.99079 6.98605 6.58508 7.12245 6.22401 6.86036 6.34938 6.1593 5.87831 6.08977 5.0965 5.00399 4.68377 4.18568 2.8965
+threshold=0.44444541990764314 0.70062845714719713 0.75617247776303531 0.7645406242769327 0.53179766719418564 0.50671990539912803 11.35416666666667 6.322916666666667 57.738095238095248 21.387500000000003 26.401785714285719 11.866071428571431 0.37542254586435625 0.021174040484134952 0.37587731721902251 0.64837092731829593 0.73563272044162131 0.55383792139841859 0.51117533329139231 20.145833333333339 20.937500000000004 0.48209613271233459 12.062500000000002 0.14583333333333218
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=10 2 4 21 5 9 -5 -8 -7 -2 13 22 17 14 16 -16 -1 -13 -19 -6 -18 -4 -3 -21
+right_child=1 11 3 6 19 8 7 -9 -10 -11 -12 12 -14 -15 15 -17 20 18 -20 23 -22 -23 -24 -25
+leaf_value=-0.0010761821563351997 -0.0504521132857738 -0.020888576146344352 0.063381196536312773 0.031300149180180752 -0.0091861880185250058 0.032629739057098435 0.026755708854807866 -0.014960107933453847 -0.014669550109854696 0.0014514898694815139 0.062084955523258885 -0.047888703413600249 0.024824846695046907 0.053148590255660884 0.022272644170989585 -0.022746839774489575 0.064616726934294752 -0.033579092631573867 0.012687158247053376 -0.033188047394488003 0.026459678285886239 0.014128239830164315 -0.063091908329842183 -0.070867855155932621
+leaf_weight=7.7214295715093639 8.7155217230319995 6.5707600712776175 5.9724875986576063 10.170844271779059 7.820334509015086 14.327638953924181 9.4181414246559125 38.771787792444229 8.1518821418285352 7.9293809384107581 8.7924163937568647 9.4247248619794863 6.3216789960861197 9.8318816572427732 10.185996487736704 9.8688251972198469 8.5203529894351977 8.5675740987062472 9.7116009145975095 7.3497301340103132 15.507762670516966 6.3991550505161285 8.7900275439023954 5.8721687346696854
+leaf_count=31 36 27 24 41 32 58 38 157 33 32 36 40 26 40 41 40 35 36 40 30 63 26 38 24
+internal_value=0.00207304 -0.00834038 -0.00269623 0.00649292 -0.0134991 -0.00205203 -0.000166073 -0.00680725 0.0154773 -0.025726 0.0287296 -0.0233003 -0.0134864 0.0239715 0.018434 0.000118899 0.0300029 -0.0222285 -0.00899815 -0.0347829 0.0399901 0.0379054 -0.0450389 -0.0499226
+internal_weight=250.714 180.285 130.899 70.7324 60.1667 39.1244 58.3608 48.1899 22.4795 16.6449 70.4287 49.3864 34.0256 61.6362 51.8044 20.0548 31.7495 27.7039 18.2792 21.0422 24.0281 12.3716 15.3608 13.2219
+internal_count=1024 738 531 286 245 159 236 195 91 68 286 207 142 250 210 81 129 116 76 86 98 50 65 54
+is_linear=0
+shrinkage=0.04
+
+
+Tree=10
+num_leaves=17
+num_cat=0
+split_feature=77 77 46 27 54 57 10 43 97 43 40 54 36 76 74 37
+split_gain=38.196 8.66905 8.17628 11.664 9.48906 7.12349 6.31154 5.47718 7.96438 4.78449 4.32492 4.31373 3.38709 2.74196 2.35164 0.967464
+threshold=1.3550000000000002 3.2850000000000006 0.30594944598976864 -7.9791666666666661 21.145833333333339 39.267857142857146 82.267857142857153 0.517251622710314 -4.4062499999999991 0.53429184335543722 13.062500000000002 21.387500000000003 0.25833333333333336 1.6050000000000002 0.49258241758241766 4.354166666666667
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=7 2 13 11 6 -6 -5 8 -1 14 -9 -4 15 -2 -3 -10
+right_child=1 9 3 4 5 -7 -8 10 12 -11 -12 -13 -14 -15 -16 -17
+leaf_value=0.0010938350878875731 -0.056271458252691184 -0.059825392191432909 0.059788669423910978 -0.039005664596234592 0.013116780911492858 -0.0075331438797635181 -0.0060155405307781556 -0.0070478699384603017 0.069320208232492922 -0.0094715712429085195 0.037723823315383334 0.012087841826597247 0.032449698237748015 -0.017612173431570215 -0.028207255364314641 0.049213209433963845
+leaf_weight=6.4049855172634116 5.8483278751373273 7.5306213200092333 5.9356311261653882 18.997604206204414 43.460418909788132 69.426650807261467 18.137169808149338 8.3646507412195188 10.436919420957571 11.170329853892325 5.8781122714281073 6.2036552876234055 10.014484807848929 5.8936225026845932 7.5243068188428879 6.0471841692924491
+leaf_count=26 24 32 24 79 177 282 74 34 43 47 24 25 41 24 32 25
+internal_value=-0.000237742 -0.00786817 -0.00463523 -0.00230133 -0.00535295 0.000416875 -0.0228928 0.0321521 0.0411221 -0.0293062 0.0114298 0.0354117 0.0507973 -0.0368673 -0.044023 0.061944
+internal_weight=247.275 200.128 173.903 162.161 150.022 112.887 37.1348 47.1463 32.9036 26.2253 14.2428 12.1393 26.4986 11.742 15.0549 16.4841
+internal_count=1013 820 709 661 612 459 153 193 135 111 58 49 109 48 64 68
+is_linear=0
+shrinkage=0.04
+
+
+Tree=11
+num_leaves=17
+num_cat=0
+split_feature=77 77 46 86 10 15 15 82 23 59 38 40 31 28 26 76
+split_gain=35.3726 8.07222 7.58645 6.89209 6.39755 8.67145 7.68194 5.36328 4.76149 6.47719 8.94184 5.29839 3.97447 5.87629 4.03464 2.57596
+threshold=1.3550000000000002 3.2850000000000006 0.30594944598976864 2.1550000000000007 81.291666666666671 -3.3523809523809471 -7.5624999999999991 1.7550000000000001 1.5000000000000002 22.062500000000004 3.0625000000000004 13.550000000000002 21.550000000000004 41.937500000000007 7.2708333333333348 1.6050000000000002
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=8 2 15 4 5 -4 -6 -5 9 10 -1 -10 14 -14 -3 -2
+right_child=1 12 3 7 6 -7 -8 -9 11 -11 -12 -13 13 -15 -16 -17
+leaf_value=0.028732650584569908 -0.054519811278789007 -0.064491542130753823 0.014624725366248799 -0.0085976653870859041 -0.017414530959728048 -0.043244668184488785 0.0081240637328352395 -0.056808196775163779 0.027059814047174627 0.044509876383840984 -0.03008579237684399 0.070067154331982448 0.011727805368536705 -0.043007463941734977 -0.020379238714872804 -0.016944262076966699
+leaf_weight=10.437584459781652 5.7958323061466199 7.0121503621339816 6.5479190945625332 9.3588718920946103 22.927828788757324 11.280139639973639 105.82874263823032 6.0974729955196372 9.9562236517667788 11.169452026486395 6.8490484803915015 8.4930274337530118 7.1303854584693891 5.6052840352058411 6.2962067276239395 5.8811570256948471
+leaf_count=43 24 30 27 38 94 47 430 25 41 46 28 35 30 24 27 24
+internal_value=-0.000229245 -0.00756918 -0.0044558 -0.00221187 0.000466882 -0.0219903 0.00357638 -0.0276165 0.0310303 0.0207685 0.0054285 0.046858 -0.0283359 -0.0123625 -0.0436219 -0.0355948
+internal_weight=246.667 199.762 173.718 162.041 146.585 17.8281 128.757 15.4563 46.9053 28.4561 17.2866 18.4493 26.044 12.7357 13.3084 11.677
+internal_count=1013 820 709 661 598 74 524 63 193 117 71 76 111 54 57 48
+is_linear=0
+shrinkage=0.04
+
+
+Tree=12
+num_leaves=23
+num_cat=0
+split_feature=77 77 52 75 51 26 74 17 75 82 54 32 27 33 81 83 85 32 72 61 77 52
+split_gain=32.7624 7.68874 8.64181 8.25451 7.32214 6.8233 6.75593 6.44176 8.25947 8.69321 6.36363 7.17186 5.52164 5.23358 7.14313 7.28422 6.71979 4.33821 3.0057 2.88005 2.0103 1.97945
+threshold=1.3550000000000002 2.7750000000000004 26.437500000000004 0.36503968253968255 0.0031256509629944006 8.0104166666666696 0.53482673267326752 5.7142857142857162 0.37048387096774199 1.5250000000000001 21.387500000000003 23.401785714285719 0.041666666666666609 0.48750000000000077 1.5450000000000002 0.49675474226372424 7.0000000000000009 23.937500000000004 168.45500000000001 12.866071428571431 3.5750000000000006 20.937500000000004
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=13 2 7 17 -4 6 -5 8 -2 -10 -9 -12 -6 14 -1 16 -16 18 -3 -15 -20 -17
+right_child=1 3 4 5 12 -7 -8 10 9 -11 11 -13 -14 19 15 21 -18 -19 20 -21 -22 -23
+leaf_value=-0.013704229151213245 0.027450875173411476 -0.023064966047954667 -0.0059624168736026485 -0.038589566739523094 0.056326441355657071 0.030446921359459631 0.016883396721917278 -0.016350382639718393 0.013627075998421501 -0.021633517290006031 0.05028258642359236 0.0009173349354000002 0.0072316487440658916 0.068524301803199614 -0.018133517520923233 0.068692298622940004 0.040971194599499342 -0.0050561417900614513 -0.063950555049639521 0.032780066279364729 -0.033589087879592569 0.036867444471177346
+leaf_weight=7.3369961380958548 7.6220861226320258 8.4552565813064628 11.61829833686352 9.1469356268644351 8.95874175429344 7.0741493850946418 5.7027423083782187 10.210099041461946 13.296437010169027 70.522654443979263 8.4501094073057192 10.635228663682936 6.2034237682819358 6.9417874813079816 6.5973821580410021 6.2351381480693799 5.7690534591674805 6.4230835288763037 9.5591890364885312 7.5070647299289703 5.4950702935457221 6.273080438375473
+leaf_count=30 31 36 47 39 36 29 24 42 54 288 34 43 25 29 27 26 24 27 41 31 24 26
+internal_value=-0.000221457 -0.00728287 -0.00262557 -0.0205316 0.0179311 -0.00188419 -0.0172862 -0.00718521 -0.0124149 -0.01604 0.0091383 0.022774 0.0362399 0.0299509 0.0209788 0.0312089 0.00943936 -0.0341897 -0.0421493 0.049953 -0.0528681 0.0527316
+internal_weight=246.034 199.374 147.517 51.8564 26.7805 21.9238 14.8497 120.737 91.4412 83.8191 29.2954 19.0853 15.1622 46.6605 32.2117 24.8747 12.3664 29.9326 23.5095 14.4489 15.0543 12.5082
+internal_count=1013 820 600 220 108 92 63 492 373 342 119 77 61 193 133 103 51 128 101 60 65 52
+is_linear=0
+shrinkage=0.04
+
+
+Tree=13
+num_leaves=19
+num_cat=0
+split_feature=77 27 31 81 14 38 21 55 43 97 42 50 49 41 11 29 36 46
+split_gain=30.365 7.27107 9.52487 12.2996 9.0589 7.41691 9.90203 7.25389 5.08675 7.54296 5.07106 4.74587 4.44817 3.59305 3.39298 3.01366 2.9941 0.448837
+threshold=1.3550000000000002 -9.1770833333333304 19.267857142857146 1.7250000000000003 122.31250000000001 2.6904761904761911 0.083333333333333273 24.291666666666668 0.517251622710314 -3.4687499999999996 -1.0000000180025095e-35 0.74140914232826016 0.76659506707061065 13.937500000000002 82.225000000000009 31.645833333333339 0.25833333333333336 0.36329415664585835
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=8 10 3 13 5 6 -4 -7 9 -1 -2 -5 -10 15 -13 -3 17 -11
+right_child=1 2 4 11 -6 7 -8 -9 12 16 -12 14 -14 -15 -16 -17 -18 -19
+leaf_value=0.0041476899979937393 -0.0034999926541034228 -0.023850556255963173 0.062374335339732266 0.019436960650830851 -0.040563681465367818 -0.014906923971429929 -0.0074965637413479513 0.0059412375908438819 0.030706710820604975 0.065449418006224877 0.045123507823127261 -0.039381405838009649 -0.014252467415403541 -0.014092509822306006 -0.0010383997769504584 -0.056317419451033038 0.031129941687341473 0.051133321323921815
+leaf_weight=8.055756524205206 6.7893940508365631 6.2344330102205339 6.6629877835512143 9.740582004189493 9.6089727431535703 49.483073160052299 6.3268143832683563 58.00315548479557 7.2527140378952009 9.1974637508392352 6.9395729303359968 6.112829089164733 6.8431497812271118 6.5173709690570822 9.326295539736746 17.179670557379723 9.3787097781896573 5.6604025810956946
+leaf_count=33 28 26 27 40 40 203 26 237 30 39 28 26 28 27 39 73 39 24
+internal_value=-0.000213824 -0.00700969 -0.00909187 -0.0230288 -0.00318742 -0.000206347 0.028343 -0.00365656 0.0289287 0.03768 0.0210777 -0.00242612 0.00888028 -0.0403607 -0.0162196 -0.0476725 0.0488255 0.0599954
+internal_weight=245.313 198.925 185.196 55.1112 130.085 120.476 12.9898 107.486 46.3882 32.2923 13.729 25.1797 14.0959 29.9315 15.4391 23.4141 24.2366 14.8579
+internal_count=1013 820 764 231 533 493 53 440 193 135 56 105 58 126 65 99 102 63
+is_linear=0
+shrinkage=0.04
+
+
+Tree=14
+num_leaves=22
+num_cat=0
+split_feature=77 77 46 75 82 55 32 17 38 46 57 30 61 33 98 65 51 27 98 47 61
+split_gain=28.1527 7.12874 8.477 7.73926 6.50746 5.98775 7.72785 8.6859 7.74875 5.93269 5.06747 5.06776 4.95308 4.91574 6.80815 7.34665 4.31144 3.2933 2.95919 4.65978 2.76263
+threshold=1.3550000000000002 2.7750000000000004 0.31724837366825204 0.36503968253968255 1.6250000000000002 25.387500000000003 23.162500000000005 5.4375000000000009 4.5357142857142865 0.38268646215659091 43.267857142857146 1.616071428571429 12.937500000000002 0.48750000000000077 -7.4374999999999991 0.33749469440953833 -0.013613105968960247 -1.0000000180025095e-35 -3.8124999999999996 0.35584581233114326 12.866071428571431
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=13 2 17 9 -5 6 7 -4 -8 18 11 -7 -6 14 -1 -16 -17 -2 19 -3 -15
+right_child=1 3 5 4 12 10 8 -9 -10 -11 -12 -13 -14 20 15 16 -18 -19 -20 -21 -22
+leaf_value=0.049192658968065413 -0.0067623296175654806 -0.0059097661371454915 -0.0050944451331990034 -0.03421558742429949 0.036155385236969206 0.014169839641633519 -0.043477105235728328 0.028316035394997729 0.0010581675575233177 0.003886886786396461 -0.0086753300433371153 0.054580295048802033 -0.0096808854134481682 0.065934772628735538 -0.023746444878321241 0.051631222052607971 0.0076433857618228972 -0.040918404046466461 -0.058216504004969173 -0.052238605686860437 0.030637453650431135
+leaf_weight=8.7887725979089755 7.5061362385749844 6.7677073627710378 50.746787026524544 6.7268268465995815 7.4960924834012967 19.041952610015873 13.521969988942148 16.497406467795372 11.624812230467795 5.6693915277719489 10.139670595526693 6.716789945960044 7.5927126258611679 6.7980895787477476 7.8056097179651287 5.6656755805015573 9.6161311566829646 11.340498879551886 10.0033008903265 7.136577308177948 7.4203208535909653
+leaf_count=37 31 29 208 29 31 77 55 67 47 24 41 27 32 29 32 24 40 47 44 31 31
+internal_value=-0.000206417 -0.00674501 -0.00226535 -0.0195702 -0.00149628 0.00141462 -0.00397204 0.00310234 -0.0228894 -0.0329013 0.0152781 0.0247072 0.0130905 0.0279552 0.0192311 0.00782548 0.0239517 -0.0273149 -0.0416252 -0.0296887 0.0475138
+internal_weight=244.623 198.529 147.136 51.3926 21.8156 128.289 92.391 67.2442 25.1468 29.577 35.8984 25.7587 15.0888 46.0946 31.8762 23.0874 15.2818 18.8466 23.9076 13.9043 14.2184
+internal_count=1013 820 600 220 92 522 377 275 102 128 145 104 63 193 133 96 64 78 104 60 60
+is_linear=0
+shrinkage=0.04
+
+
+Tree=15
+num_leaves=23
+num_cat=0
+split_feature=77 78 26 31 57 17 43 18 88 36 86 43 43 83 26 73 29 74 16 55 49 68
+split_gain=30.6549 12.7043 7.98721 10.8099 12.9808 8.83958 9.66696 7.6233 8.30341 7.00237 7.84435 6.65312 6.67534 5.83636 5.52421 4.95185 4.66908 4.3802 2.29615 1.92109 0.661162 0.1601
+threshold=1.9950000000000003 0.33644919786096261 21.770833333333339 20.133928571428573 35.187500000000007 -5.0624999999999991 0.53857630126707601 1.8541666666666716 0.53866359200690284 0.82291666666666663 1.8550000000000002 0.45900318339543572 0.4818732325807798 0.47597575932472408 12.94791666666667 0.53851851851851873 32.38750000000001 0.45972972972972981 3.4375000000000004 22.133928571428573 0.73531540336276224 213.70833333333334
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 14 3 13 -5 17 -7 8 11 10 -9 -3 -13 -2 15 -1 -15 -6 -12 -17 -18 -21
+right_child=2 7 -4 4 5 6 -8 9 -10 -11 18 12 -14 16 -16 19 20 -19 -20 21 -22 -23
+leaf_value=0.010871073320075295 -0.01172908397497561 -0.046441338207332344 0.019672691938767486 0.046075447983197577 -0.061569404959666424 0.0074003860750678123 -0.03202888807961754 0.0051474644513716042 0.036884377615520249 -0.003400242373786107 0.074863846195407729 0.029393863715199694 -0.0074553467007233889 -0.02523852343490229 -0.00025978536454887422 0.034473210798287857 -0.04795709241166466 -0.021389238996026894 0.039593407313705566 0.06652884725665352 -0.0649082592606154 0.057420779027093437
+leaf_weight=5.6847298443317476 11.006925001740454 5.903722643852233 9.1704158484935743 6.0783775299787512 7.7922967374324825 29.886689186096191 14.913227543234823 7.632679730653769 8.1395289301872236 10.812797814607618 5.8884793967008573 9.226744741201399 53.322611838579178 10.414219856262209 5.7322616279125205 5.7362669706344631 5.4735058695077923 9.8010887205600721 5.9245722442865372 6.8773611485958082 11.245072126388548 5.6040449738502502
+leaf_count=24 47 25 38 25 33 123 62 31 33 44 24 38 218 44 24 24 24 42 24 29 48 24
+internal_value=-0.00100969 0.011833 -0.0161489 -0.0192302 -0.00972405 -0.0151601 -0.00572503 0.00540609 -0.00130932 0.0224046 0.0367534 -0.00585081 -0.00201967 -0.0362963 0.0350059 0.0434633 -0.0462625 -0.0391855 0.0571747 0.0536336 -0.0593586 0.0624394
+internal_weight=252.268 136.486 115.782 106.611 68.4717 62.3933 44.7999 106.851 76.5926 30.2585 19.4457 68.4531 62.5494 38.1397 29.6347 23.9024 27.1328 17.5934 11.8131 18.2177 16.7186 12.4814
+internal_count=1048 562 486 448 285 260 185 437 314 123 79 281 256 163 125 101 116 75 48 77 72 53
+is_linear=0
+shrinkage=0.04
+
+
+Tree=16
+num_leaves=17
+num_cat=0
+split_feature=76 76 33 62 60 32 55 73 17 64 98 25 97 51 64 46
+split_gain=28.3621 12.2502 8.00023 7.56697 8.78584 8.59503 10.2753 7.68395 7.41413 7.20524 7.00591 5.23347 2.9989 2.73623 2.05561 2.04323
+threshold=1.4350000000000003 2.4650000000000003 4.2946428571428585 0.47839506172839513 11.437500000000002 16.162500000000005 19.854166666666668 0.53494186046511638 -7.4374999999999991 0.32494646077353467 5.2142857142857162 7.713541666666667 3.7187500000000004 -0.004282105062106599 0.35502948224071251 0.3406679635524858
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=3 2 8 15 12 -6 -7 -8 -2 -10 -11 13 14 -3 -5 -1
+right_child=1 11 -4 4 5 6 7 -9 9 10 -12 -13 -14 -15 -16 -17
+leaf_value=-0.029356541192986724 0.037955112610862249 0.059695040893734667 0.043145015879701695 -0.032469843140688813 -0.046002450801952505 0.045093595797352712 -0.042281712918251578 -0.0013799114657325063 0.028081928029134246 -0.010286395434884021 0.025869758711122577 0.011074792109595291 -0.016203413481459306 0.029391271532808353 -0.066050254966225394 -0.059556082391998284
+leaf_weight=8.2328822761774045 8.3526985198259336 10.85255688428879 8.1492396891117078 6.0218881517648715 7.7615482956171027 6.8014763444662085 8.401523217558859 58.652556464076042 11.53392608463764 68.72949393093586 9.7969980090856534 10.286443859338759 7.4116774648427954 8.5023315101861971 5.6562657654285431 6.3488157242536536
+leaf_count=36 34 47 33 26 33 28 36 245 47 282 40 43 31 36 24 27
+internal_value=-0.000973738 0.0113848 0.00505797 -0.0155743 -0.0116748 -0.00596092 -0.00175292 -0.00650469 0.00190411 -0.00143945 -0.00577554 0.03413 -0.0361041 0.046383 -0.0487344 -0.0425053
+internal_weight=251.492 136.204 106.562 115.289 100.707 81.6171 73.8556 67.0541 98.4131 90.0604 78.5265 29.6413 19.0898 19.3549 11.6782 14.5817
+internal_count=1048 562 436 486 423 342 309 281 403 369 322 126 81 83 50 63
+is_linear=0
+shrinkage=0.04
+
+
+Tree=17
+num_leaves=22
+num_cat=0
+split_feature=76 76 33 26 31 57 43 97 60 18 96 88 18 83 26 39 73 7 55 45 68
+split_gain=26.2331 11.4465 7.36965 7.34122 10.0074 11.7565 7.00539 6.9993 6.88815 10.1637 8.77606 8.04063 5.85928 5.44514 5.13063 4.51191 4.39613 4.1986 1.8532 1.64881 0.156111
+threshold=1.4350000000000003 2.4650000000000003 4.2946428571428585 21.770833333333339 20.133928571428573 35.187500000000007 0.53857630126707601 4.7812500000000009 12.937500000000002 7.8125000000000009 227.02083333333337 0.50795806360821849 -4.2250000000000076 0.47597575932472408 12.94791666666667 -0.14642857142857144 0.53851851851851873 38.750000000000007 22.133928571428573 -0.022501766737042645 213.70833333333334
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=3 2 8 4 13 -6 7 -7 10 12 11 -2 -10 -1 16 -8 -3 -15 -18 -19 -20
+right_child=1 14 -4 -5 5 6 15 -9 9 -11 -12 -13 -14 17 -16 -17 18 19 20 -21 -22
+leaf_value=-0.010786926974099898 -0.010875891059966199 0.011190352480577235 0.041404682122757074 0.019321738062697564 0.044141656903284171 0.0050650165981334172 -0.0061370748531028195 -0.031081442136894771 0.0018664483503017856 0.037131975018793693 0.045073208415421694 0.031828378125081415 -0.026128862170482447 -0.019454829109928577 -0.00098318851507109848 -0.04740967911986986 0.032230447411375152 -0.036142993762053356 0.064020839936514432 -0.062063497067667478 0.054909341919742859
+leaf_weight=10.931022465229033 21.17684800922871 5.8557388037443223 8.1520167738199216 9.167889401316641 6.0991687178611746 30.766112342476845 6.2713132798671749 11.881261780858038 21.166444480419155 7.1458795964717856 10.812558114528654 10.578455105423926 27.506209731101993 7.7223432809114483 5.709469035267829 13.0707770884037 5.6604651659727123 5.5588853806257275 6.7105195671319944 13.371022954583166 5.4539281576871872
+leaf_count=47 87 25 33 38 25 128 26 50 87 29 44 43 113 33 24 56 24 24 29 59 24
+internal_value=-0.00093843 0.0109531 0.00485653 -0.0150137 -0.0179926 -0.00884725 -0.0140609 -0.00500514 0.00182825 -0.00741437 0.013948 0.00334993 -0.0139544 -0.034561 0.0330532 -0.0340278 0.0412595 -0.0443116 0.0511376 -0.0544518 0.0599357
+internal_weight=250.768 135.929 106.538 114.84 105.672 68.0886 61.9895 42.6474 98.3864 55.8185 42.5679 31.7553 48.6727 37.5833 29.3901 19.3421 23.6807 26.6523 17.8249 18.9299 12.1644
+internal_count=1048 562 436 486 448 285 260 178 403 229 174 130 200 163 126 82 102 116 77 83 53
+is_linear=0
+shrinkage=0.04
+
+
+Tree=18
+num_leaves=16
+num_cat=0
+split_feature=78 79 27 72 42 35 26 33 9 30 47 48 55 36 10
+split_gain=24.4334 9.31464 8.11491 7.61266 8.41054 8.43587 6.62119 7.15164 9.45035 5.28003 4.33177 4.03099 3.63878 2.72794 1.40327
+threshold=0.39285714285714285 0.25425685425685435 -9.1770833333333304 165.36681435533896 -3.4833333333333329 9.133928571428573 2.0104166666666674 0.48750000000000077 -37.987012987012982 -0.56249999999999989 0.37693449058527589 0.029982232931730853 20.062500000000004 0.19374999999999967 112.93750000000001
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=6 11 -3 10 -5 -6 14 8 -8 -10 12 13 -4 -2 -1
+right_child=1 2 3 4 5 -7 7 -9 9 -11 -12 -13 -14 -15 -16
+leaf_value=0.063369704073235666 -0.060192057816396222 0.028277022360530538 -0.016384609809915053 0.044115984475752157 -0.002478065592223366 -0.051567336834095104 0.039068426318397236 0.043825566156782063 0.011510346359810335 -0.030717352367799409 0.0045260873425609898 -0.0079952149779249845 -0.050175542136173798 -0.02646344151553905 0.03565855117598455
+leaf_weight=6.1944728344678861 7.4922285825014132 11.610384106636046 9.429924696683889 5.9105293601751319 126.33686858415604 5.8609887659549704 9.0260636359453184 10.688595429062842 9.03087270259857 9.9656709432601982 5.7869970500469199 8.0647390484809858 11.101787701249121 7.8635760098695755 5.5375995486974716
+leaf_count=27 34 47 40 24 521 24 39 46 38 41 24 36 48 35 24
+internal_value=-0.000905355 -0.00719526 -0.00404233 -0.00632444 -0.00256724 -0.00465444 0.0239656 0.0159876 0.00536936 -0.0106425 -0.0260405 -0.0308938 -0.0346558 -0.0429199 0.0502899
+internal_weight=249.901 199.458 176.037 164.427 138.108 132.198 50.4433 38.7112 28.0226 18.9965 26.3187 23.4205 20.5317 15.3558 11.7321
+internal_count=1048 833 728 681 569 545 215 164 118 79 112 105 88 69 51
+is_linear=0
+shrinkage=0.04
+
+
+Tree=19
+num_leaves=18
+num_cat=0
+split_feature=76 76 62 60 60 32 55 33 17 64 86 25 97 63 12 64 81
+split_gain=23.1068 9.98848 7.01309 7.92354 7.95102 8.25678 10.3579 6.71651 6.62639 6.59888 6.66891 4.82438 2.76159 2.56144 2.27179 1.91893 0.744688
+threshold=1.4350000000000003 2.4650000000000003 0.47839506172839513 11.437500000000002 15.225000000000001 16.162500000000005 19.854166666666668 4.2946428571428585 -7.4374999999999991 0.32494646077353467 2.1850000000000005 7.713541666666667 3.7187500000000004 0.4972961247664654 -0.52499999999999847 0.35502948224071251 1.675
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=2 7 14 12 5 -5 -7 8 -2 -10 -11 13 15 -3 -1 -4 -15
+right_child=1 11 3 4 -6 6 -8 -9 9 10 -12 -13 -14 16 -16 -17 -18
+leaf_value=-0.020188921856989679 0.035859126989343022 0.020130209700355124 -0.030330032249617687 -0.042500863549311367 -0.05090993952028721 0.051411801287769635 -0.0022541904826031737 0.03956776202840788 0.026837614548232368 -0.0020673320148814839 -0.04439110542553347 0.008982843264200761 -0.014705883428948159 0.04205717024579949 -0.053006940553933922 -0.063196273867381317 0.061135640318500738
+leaf_weight=5.4853323251008979 8.3379970937967283 5.4507957398891511 5.8967574089765566 7.1303204596042624 5.6088133603334418 6.3442998528480521 61.878040820360184 8.1366265416145307 11.526250436902044 71.76362943649292 6.4958909302949897 10.161600232124327 7.33974365890026 5.8689189553260785 8.7720085084438306 5.4874216467142105 7.4020354598760605
+leaf_count=24 34 24 26 31 24 26 261 33 47 295 27 43 31 26 39 24 33
+internal_value=-0.000872267 0.0103144 -0.0141404 -0.0103874 -0.00496412 -0.00154418 0.00273645 0.00464481 0.00174893 -0.00141873 -0.00558039 0.0311724 -0.0338375 0.0432163 -0.0403806 -0.0461723 0.0526984
+internal_weight=249.086 135.144 113.943 99.6854 80.9615 75.3527 68.2223 106.26 98.1238 89.7858 78.2595 28.8834 18.7239 18.7218 14.2573 11.3842 13.271
+internal_count=1048 562 486 423 342 318 287 436 403 369 322 126 81 83 63 50 59
+is_linear=0
+shrinkage=0.04
+
+
+Tree=20
+num_leaves=21
+num_cat=0
+split_feature=77 85 42 26 33 48 29 51 51 88 47 49 9 43 18 45 13 97 90 77
+split_gain=21.5323 9.97521 10.2057 13.3659 8.32088 7.657 7.45302 7.27519 7.64625 7.10753 6.89749 6.08818 4.68215 4.36106 4.27259 4.17883 3.76513 3.4333 0.930107 0.105107
+threshold=1.3050000000000004 -5.9999999999999991 1.0000000180025095e-35 9.0104166666666696 4.4375000000000009 0.059692514253813854 39.812500000000007 0.045203152003977003 0.023949864400422651 0.52433570113128136 0.36314281963351264 0.78248216953695626 -13.09523809523809 0.51328944240770225 -16.645833333333325 -0.0072528547698737485 85.062500000000014 1.0937500000000002 0.19841107122821819 3.1550000000000007
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=12 2 6 9 5 7 16 8 -3 15 -9 17 14 -14 -1 -4 -2 -8 -16 -18
+right_child=1 4 3 -5 -6 -7 11 10 -10 -11 -12 -13 13 -15 18 -17 19 -19 -20 -21
+leaf_value=0.013957264641046819 -0.027472132914840498 -0.0020934000360734932 0.022613724189803789 0.050832305755293579 0.037916740044630914 0.040588735510979898 0.027960766295875104 -0.003405364332683979 -0.031143520168862283 -0.05384418391600191 0.040275812485981034 -0.044330514984326927 0.030259337595429918 -0.015671661984799638 0.062645279427693656 -0.020045453140862098 -0.066399946636320761 -0.01585144878027565 0.043445571662247148 -0.058570658366565144
+leaf_weight=7.1345093548297873 8.8107999712228793 87.334490463137627 6.9631915688514745 6.7626315653324118 9.8303922265768033 6.9817947149276725 5.6945501416921633 11.879387885332109 17.382111921906471 5.3163712173700324 11.272227853536604 5.8104494661092749 7.708228871226309 5.7933596074581146 6.5536312311887803 7.778242379426958 5.6191599071025831 5.7529874593019485 10.513165161013601 5.361001193523407
+leaf_count=31 39 362 29 28 40 29 24 49 72 24 46 25 33 25 29 33 24 25 47 25
+internal_value=0.00160475 -0.00342443 -0.0165911 0.00220167 0.002388 -0.000201998 -0.0301955 -0.00242923 -0.00691549 -0.0141945 0.0178624 -0.0109833 0.0294231 0.0105509 0.0399517 0.000104827 -0.0469487 0.00594283 0.0508182 -0.0625773
+internal_weight=246.253 208.55 63.8694 26.8204 144.68 134.85 37.0489 127.868 104.717 20.0578 23.1516 17.258 37.7029 13.5016 24.2013 14.7414 19.791 11.4475 17.0668 10.9802
+internal_count=1039 874 276 114 598 558 162 529 434 86 95 74 165 58 107 62 88 49 76 49
+is_linear=0
+shrinkage=0.04
+
+
+Tree=21
+num_leaves=21
+num_cat=0
+split_feature=77 85 42 26 25 51 29 88 90 36 49 14 9 18 61 43 13 59 90 77
+split_gain=20.02 9.2622 9.52085 12.2814 7.88967 7.82256 7.04841 6.6998 6.53054 7.87452 5.68149 5.30824 4.42523 4.07084 4.07033 4.04241 3.62375 3.25279 0.898801 0.0879165
+threshold=1.3050000000000004 -5.9999999999999991 1.0000000180025095e-35 9.0104166666666696 1.8541666666666667 0.080538861184771923 39.812500000000007 0.52433570113128136 0.19969875129044842 -1.0875000000000001 0.78248216953695626 118.93750000000001 -13.09523809523809 -16.645833333333325 13.816666666666668 0.51328944240770225 85.062500000000014 23.535714285714288 0.19841107122821819 3.1550000000000007
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=12 2 6 7 -3 8 16 14 11 -10 17 -6 13 -1 -4 -14 -2 -8 -15 -18
+right_child=1 4 3 -5 5 -7 10 -9 9 -11 -12 -13 15 18 -16 -17 19 -19 -20 -21
+leaf_value=0.013447805314569216 -0.026577780088672762 0.034080468035460186 0.017293051569916593 0.048557724592127684 0.007825469574374657 0.040280280315047955 -0.016199932862450934 -0.052623204127446775 -0.047796064224015833 -0.0064826859346349495 -0.043040720837339654 -0.024990244369414837 0.029249467101270982 0.061303641269563863 -0.025610761209309305 -0.014994478156697251 -0.064751343135519002 0.026458734247185672 0.042272167151271647 -0.057522795432648433
+leaf_weight=7.10912762582302 8.7443605959415454 11.499579980969427 8.8282703608274513 6.7955194860696784 70.869819477200508 7.13891777396202 5.5701393187046069 5.2240076065063468 9.2205274105072004 37.017053097486496 5.7464897632598868 8.8745380789041501 7.6564510315656644 6.4316389113664689 5.9041270762681952 5.8124003708362579 5.5334616154432279 5.8780088722705841 10.375598087906836 5.2427052408456802
+leaf_count=31 39 47 37 28 292 29 24 24 39 154 25 37 33 29 25 25 24 25 47 25
+internal_value=0.00154432 -0.00329759 -0.0160366 0.0021131 0.00229294 -0.000453006 -0.029261 -0.0137021 -0.00276121 -0.0147212 -0.0105873 0.0041735 0.0284946 0.0388221 9.90026e-05 0.0101563 -0.0457098 0.005703 0.049555 -0.0612346
+internal_weight=245.473 208.088 63.4671 26.7519 144.62 133.121 36.7152 19.9564 125.982 46.2376 17.1946 79.7444 37.3852 23.9164 14.7324 13.4689 19.5205 11.4481 16.8072 10.7762
+internal_count=1039 874 276 114 598 551 162 86 522 193 74 329 165 107 62 58 88 49 76 49
+is_linear=0
+shrinkage=0.04
+
+
+Tree=22
+num_leaves=18
+num_cat=0
+split_feature=77 78 25 48 51 25 9 35 9 48 27 30 9 18 43 50 72
+split_gain=18.621 8.70394 7.91958 7.02031 6.21305 7.48529 6.53645 5.17821 7.11278 5.11576 6.50119 6.92842 4.18572 3.88527 3.74781 0.796232 0.173612
+threshold=1.3050000000000004 0.69515163347650677 1.7395833333333337 0.059692514253813854 0.043626967279394004 7.8802083333333348 8.333333333333341 6.6937500000000005 8.7121212121212164 -0.018202373884811395 0.98958333333333315 0.22500000000000142 -13.09523809523809 -16.645833333333325 0.51328944240770225 0.74854124348714812 225.04250000000002
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=12 2 -2 4 6 -6 -4 8 -3 -9 11 -11 13 -1 -14 -15 -17
+right_child=1 7 3 -5 5 -7 -8 9 -10 10 -12 -13 14 15 -16 16 -18
+leaf_value=0.012956313378187341 0.036677286509223014 0.027307971594871701 -0.0022506819015889979 0.032532340700343249 0.001223625287223337 0.048438323769350811 -0.026039625377917281 -0.053747110254001744 -0.024750955618137494 -0.0073465850093818175 0.015119548741830309 -0.055928592960106001 0.028278098346949592 0.036190897477542942 -0.014350124084243559 0.059344625765782907 0.049204905261110286
+leaf_weight=7.0841730237007132 9.6115598380565626 8.2046131193637866 86.82922887802124 9.458725377917288 19.787809953093532 7.3747483491897574 23.477235645055771 8.3150889277458173 8.6016630232334119 10.108060508966451 7.039140820503234 8.7735196799039823 7.6037576496601087 5.6597618609666887 5.8300840854644775 5.8845966756343824 4.9951938986778259
+leaf_count=31 39 35 359 39 81 30 97 39 39 45 31 40 33 25 25 27 24
+internal_value=0.00148631 -0.00317645 0.00150065 -0.0008005 -0.00309401 0.0140426 -0.00731384 -0.0175205 0.000663559 -0.026447 -0.0176894 -0.0299207 0.0276052 0.0377427 0.00977809 0.0483592 0.0546892
+internal_weight=244.639 207.581 156.539 146.928 137.469 27.1626 110.306 51.0421 16.8063 34.2358 25.9207 18.8816 37.0576 23.6237 13.4338 16.5396 10.8798
+internal_count=1039 874 645 606 567 111 456 229 74 155 116 85 165 107 58 76 51
+is_linear=0
+shrinkage=0.04
+
+
+end of trees
+
+feature_importances:
+Column_77=25
+Column_46=15
+Column_76=15
+Column_97=14
+Column_43=13
+Column_50=13
+Column_49=12
+Column_27=11
+Column_78=11
+Column_9=10
+Column_26=10
+Column_51=10
+Column_55=10
+Column_61=10
+Column_17=9
+Column_18=8
+Column_25=8
+Column_36=8
+Column_42=8
+Column_52=8
+Column_74=8
+Column_75=8
+Column_81=8
+Column_33=7
+Column_40=7
+Column_48=7
+Column_73=7
+Column_86=7
+Column_10=6
+Column_31=6
+Column_32=6
+Column_44=6
+Column_57=6
+Column_88=6
+Column_13=5
+Column_29=5
+Column_35=5
+Column_60=5
+Column_64=5
+Column_85=5
+Column_90=5
+Column_15=4
+Column_23=4
+Column_30=4
+Column_37=4
+Column_38=4
+Column_41=4
+Column_45=4
+Column_47=4
+Column_54=4
+Column_58=4
+Column_59=4
+Column_62=4
+Column_65=4
+Column_83=4
+Column_95=4
+Column_98=4
+Column_8=3
+Column_12=3
+Column_63=3
+Column_72=3
+Column_82=3
+Column_7=2
+Column_11=2
+Column_14=2
+Column_16=2
+Column_56=2
+Column_68=2
+Column_21=1
+Column_22=1
+Column_28=1
+Column_34=1
+Column_39=1
+Column_53=1
+Column_69=1
+Column_79=1
+Column_89=1
+Column_96=1
+
+parameters:
+[boosting: gbdt]
+[objective: binary]
+[metric: binary_logloss]
+[tree_learner: serial]
+[device_type: cpu]
+[data_sample_strategy: bagging]
+[data: ]
+[valid: ]
+[num_iterations: 1200]
+[learning_rate: 0.04]
+[num_leaves: 31]
+[num_threads: 4]
+[seed: 42]
+[deterministic: 0]
+[force_col_wise: 0]
+[force_row_wise: 0]
+[histogram_pool_size: -1]
+[max_depth: 6]
+[min_data_in_leaf: 24]
+[min_sum_hessian_in_leaf: 0.001]
+[bagging_fraction: 0.84]
+[pos_bagging_fraction: 1]
+[neg_bagging_fraction: 1]
+[bagging_freq: 5]
+[bagging_seed: 400]
+[bagging_by_query: 0]
+[feature_fraction: 0.82]
+[feature_fraction_bynode: 1]
+[feature_fraction_seed: 30056]
+[extra_trees: 0]
+[extra_seed: 12879]
+[early_stopping_round: 0]
+[early_stopping_min_delta: 0]
+[first_metric_only: 0]
+[max_delta_step: 0]
+[lambda_l1: 0]
+[lambda_l2: 0]
+[linear_lambda: 0]
+[min_gain_to_split: 0]
+[drop_rate: 0.1]
+[max_drop: 50]
+[skip_drop: 0.5]
+[xgboost_dart_mode: 0]
+[uniform_drop: 0]
+[drop_seed: 17869]
+[top_rate: 0.2]
+[other_rate: 0.1]
+[min_data_per_group: 100]
+[max_cat_threshold: 32]
+[cat_l2: 10]
+[cat_smooth: 10]
+[max_cat_to_onehot: 4]
+[top_k: 20]
+[monotone_constraints: ]
+[monotone_constraints_method: basic]
+[monotone_penalty: 0]
+[feature_contri: ]
+[forcedsplits_filename: ]
+[refit_decay_rate: 0.9]
+[cegb_tradeoff: 1]
+[cegb_penalty_split: 0]
+[cegb_penalty_feature_lazy: ]
+[cegb_penalty_feature_coupled: ]
+[path_smooth: 0]
+[interaction_constraints: ]
+[verbosity: -1]
+[saved_feature_importance_type: 0]
+[use_quantized_grad: 0]
+[num_grad_quant_bins: 4]
+[quant_train_renew_leaf: 0]
+[stochastic_rounding: 1]
+[linear_tree: 0]
+[max_bin: 255]
+[max_bin_by_feature: ]
+[min_data_in_bin: 3]
+[bin_construct_sample_cnt: 200000]
+[data_random_seed: 175]
+[is_enable_sparse: 1]
+[enable_bundle: 1]
+[use_missing: 1]
+[zero_as_missing: 0]
+[feature_pre_filter: 1]
+[pre_partition: 0]
+[two_round: 0]
+[header: 0]
+[label_column: ]
+[weight_column: ]
+[group_column: ]
+[ignore_column: ]
+[categorical_feature: ]
+[forcedbins_filename: ]
+[precise_float_parser: 0]
+[parser_config_file: ]
+[objective_seed: 16083]
+[num_class: 1]
+[is_unbalance: 0]
+[scale_pos_weight: 1]
+[sigmoid: 1]
+[boost_from_average: 1]
+[reg_sqrt: 0]
+[alpha: 0.9]
+[fair_c: 1]
+[poisson_max_delta_step: 0.7]
+[tweedie_variance_power: 1.5]
+[lambdarank_truncation_level: 30]
+[lambdarank_norm: 1]
+[label_gain: ]
+[lambdarank_position_bias_regularization: 0]
+[eval_at: ]
+[multi_error_top_k: 1]
+[auc_mu_weights: ]
+[num_machines: 1]
+[local_listen_port: 12400]
+[time_out: 120]
+[machine_list_filename: ]
+[machines: ]
+[gpu_platform_id: -1]
+[gpu_device_id: -1]
+[gpu_use_dp: 0]
+[num_gpu: 1]
+
+end of parameters
+
+pandas_categorical:null
@@ -0,0 +1,790 @@
+tree
+version=v4
+num_class=1
+num_tree_per_iteration=1
+label_index=0
+max_feature_idx=98
+objective=binary sigmoid:1
+feature_names=Column_0 Column_1 Column_2 Column_3 Column_4 Column_5 Column_6 Column_7 Column_8 Column_9 Column_10 Column_11 Column_12 Column_13 Column_14 Column_15 Column_16 Column_17 Column_18 Column_19 Column_20 Column_21 Column_22 Column_23 Column_24 Column_25 Column_26 Column_27 Column_28 Column_29 Column_30 Column_31 Column_32 Column_33 Column_34 Column_35 Column_36 Column_37 Column_38 Column_39 Column_40 Column_41 Column_42 Column_43 Column_44 Column_45 Column_46 Column_47 Column_48 Column_49 Column_50 Column_51 Column_52 Column_53 Column_54 Column_55 Column_56 Column_57 Column_58 Column_59 Column_60 Column_61 Column_62 Column_63 Column_64 Column_65 Column_66 Column_67 Column_68 Column_69 Column_70 Column_71 Column_72 Column_73 Column_74 Column_75 Column_76 Column_77 Column_78 Column_79 Column_80 Column_81 Column_82 Column_83 Column_84 Column_85 Column_86 Column_87 Column_88 Column_89 Column_90 Column_91 Column_92 Column_93 Column_94 Column_95 Column_96 Column_97 Column_98
+feature_infos=none none none none none none none [0:100] [0:100] [-100:100] [54:128.875] [61:138] [-41.333333333333329:24] [61:130.125] [59:133] [-50:34.916666666666671] [-28.666666666666657:32.5] [-24.5:27] [-35.5:31.833333333333329] [0:1] [0:1] [-1:1] [0:12] [0:12] [-12:10] [0.91666666666666663:186.1875] [0.85416666666666663:185.08333333333337] [-179.02083333333334:184.16666666666663] [20:54] [22:56] [-21:15.833333333333332] [11:34.5] [9:36] [-15:13.333333333333332] [2:13] [3:13] [-8:5.5] [0.875:9] [0:12] [-9:4.875] [7:22] [8:23] [-10:10] [0.41025641025641019:0.67647058823529416] [0.39730639730639727:0.76744186046511631] [-0.3174418604651163:0.22647058823529409] [0.20419254658385089:0.4825000000000001] [0.1875:0.54166666666666663] [-0.22171945701357459:0.17923280423280419] [0.47826086956521741:0.87898457080200498] [0.42857142857142849:0.88636363636363635] [-0.29647435897435898:0.38962801311591622] [11:39.666666666666664] [15.5:40] [10:31.875] [11.5:34] [15:56] [17:57] [12:32.125] [10:38] [8:20] [7:22] [0.40000000000000002:0.69047619047619047] [0.3902439024390244:0.71739130434782605] [0.23753976670201479:0.51851851851851849] [0.1707317073170731:0.54545454545454541] [0:8] [0:1] [120:295] [-38:36] [0:1] [0:1] [140.39130434782609:233.09999999999999] [0:1] [0:1] [0:1] [1.05:4.1100000000000003] [1.05:4.1299999999999999] [0.2034883720930232:0.79729729729729726] [0.20270270270270269:0.79651162790697683] [145.5:257.5] [1.3:7.7599999999999998] [1.4099999999999999:7.5599999999999996] [0.1789976133651551:0.75977653631284914] [0.24022346368715081:0.82100238663484482] [-15.5:12.5] [1.3:2.7200000000000002] [1.1799999999999999:2.7799999999999998] [0.36298076923076922:0.64953271028037374] [0.35046728971962621:0.63701923076923073] [0.1918833727344364:0.21555133935749429] none none none none [132:250.6875] [126.25:256.625] [-63.5:88.6875] [-35.5:27.5]
+tree_sizes=1917 2132 1711 1718 2135 1820 1814 2034 1817 1826 2446 2567 2567 2150 2344 1601 1499 1400 990 1399 1731 1721 2040 1829 1725 1721 1504 1717 1516 1931
+
+Tree=0
+num_leaves=17
+num_cat=0
+split_feature=87 40 77 86 73 40 95 12 17 82 74 40 55 71 81 53
+split_gain=15.1457 13.2046 13.5042 11.2099 13.4357 11.4245 10.2245 9.8615 9.24196 7.11979 6.96376 9.0178 6.02258 5.9784 5.26359 4.73348
+threshold=1.5850000000000002 11.267857142857144 1.7850000000000004 1.7450000000000003 0.5344873150105709 11.79166666666667 228.96875000000003 0.14583333333333573 -3.8124999999999996 1.905 0.63245614035087727 15.401785714285717 22.645833333333339 0.22500000000000003 1.7350000000000001 23.437500000000004
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=15 8 6 4 -4 -6 10 -8 -2 13 11 -3 -12 -5 -10 -1
+right_child=1 2 3 9 5 -7 7 -9 14 -11 12 -13 -14 -15 -16 -17
+leaf_value=-0.097004150398104866 -0.032826856509161513 -0.0043502309061410754 0.01431771893192204 -0.091075161948939082 -0.0036225823237434548 -0.050018228661574106 -0.029276859267249353 -0.092899466087143945 -0.061043546543381851 -0.031637052746051886 -0.012858122023405583 -0.051389190877909906 -0.063112770479224672 -0.058465725478527159 -0.099324189356474121 -0.059651523168360317
+leaf_weight=10.494576394557955 9.2452220618724805 41.228692978620529 7.2462551295757285 13.49302679300308 9.9948346614837629 56.47081583738327 9.7449637949466723 6.4966425299644461 11.494059860706331 9.9948346614837629 6.4966425299644461 7.7459968626499167 9.2452220618724805 26.986053586006165 11.494059860706328 11.244188994169233
+leaf_count=42 37 165 29 54 40 226 39 26 46 40 26 31 37 108 46 45
+internal_value=-0.0457273 -0.0428007 -0.0390611 -0.0473474 -0.0374027 -0.0430414 -0.0263504 -0.0547259 -0.0666008 -0.0618705 -0.0192291 -0.0117901 -0.0423728 -0.0693355 -0.0801839 -0.0776838
+internal_weight=259.116 237.377 205.144 124.186 73.7119 66.4657 80.9582 16.2416 32.2333 50.4739 64.7166 48.9747 15.7419 40.4791 22.9881 21.7388
+internal_count=1037 950 821 497 295 266 324 65 129 202 259 196 63 162 92 87
+is_linear=0
+shrinkage=1
+
+
+Tree=1
+num_leaves=19
+num_cat=0
+split_feature=87 40 75 64 30 36 33 63 36 17 39 47 17 64 15 30 11 25
+split_gain=13.9729 12.1763 14.362 13.4541 10.6931 12.6392 11.2985 10.0326 8.61679 8.52999 8.49866 8.85202 6.83713 6.53966 4.98946 6.17658 4.17697 6.76785
+threshold=1.5850000000000002 11.267857142857144 0.4095454545454546 0.35791741982096692 -3.850000000000001 -0.13125000000000001 2.8660714285714275 0.50088993919059788 -0.17708333333333343 -3.8124999999999996 0.4702380952380954 0.34444905543815357 -7.8374999999999977 0.33306045819490598 -4.4732142857142838 -2.0744047619047588 90.687500000000014 3.9114583333333335
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=16 9 3 12 5 -4 8 -8 -6 -2 11 -5 -3 -14 -11 -16 -1 -18
+right_child=1 2 4 10 6 -7 7 -9 -10 14 -12 -13 13 -15 15 -17 17 -19
+leaf_value=-0.057851344720467247 0.012127031371442692 -0.065070317857066393 -0.046234344564243093 -0.034302041708384759 0.0097538558374562559 0.015919168977055184 -0.044150175296378553 0.012931828545225675 0.032691802732617729 -0.063902755868288641 0.044060792595361865 0.025258066535241798 0.0038131771685337061 -0.035910700877364692 0.0058413187436127693 -0.043222266889543948 -0.041738488387342523 0.012479643131747724
+leaf_weight=6.4850978553295162 9.2475084811449033 6.2444083094596854 9.9929635822772997 8.2424890547990817 47.478157848119736 10.994390726089476 8.24348331987858 12.243208199739454 58.476858302950859 6.238056123256686 8.4939699023962003 7.743343085050582 11.740369915962221 15.236236929893492 7.2386563420295742 9.484264671802519 8.9887140691280347 6.2415239214897147
+leaf_count=26 37 25 40 33 190 44 33 49 234 25 34 31 47 61 29 38 36 25
+internal_value=-0.00025478 0.00255523 0.0061453 -0.0107729 0.0127667 -0.0136747 0.0171556 -0.010037 0.0224134 -0.0203093 0.011728 -0.00545185 -0.0273532 -0.0186226 -0.033373 -0.0219847 -0.0309668 -0.0195193
+internal_weight=259.054 237.338 205.13 57.7008 147.429 20.9874 126.442 20.4867 105.955 32.2085 24.4798 15.9858 33.221 26.9766 22.961 16.7229 21.7153 15.2302
+internal_count=1037 950 821 231 590 84 506 82 424 129 98 64 133 108 92 67 87 61
+is_linear=0
+shrinkage=0.04
+
+
+Tree=2
+num_leaves=15
+num_cat=0
+split_feature=87 79 86 40 80 29 95 46 61 76 27 42 51 53
+split_gain=12.8995 11.4587 12.6562 11.6114 9.74256 9.00377 8.40775 12.7519 9.12686 9.48882 6.86723 5.78581 4.37714 4.21145
+threshold=1.5850000000000002 0.47526524006473664 1.425 11.437500000000002 159.00000000000003 40.312500000000007 228.96875000000003 0.35543310268494094 12.225000000000001 2.6550000000000007 -13.968749999999998 -0.61249999999999971 -0.024362426215342146 23.437500000000004
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=13 2 5 -3 -4 -2 8 -8 12 -10 -6 -12 -5 -1
+right_child=1 3 4 6 10 -7 7 -9 9 -11 11 -13 -14 -15
+leaf_value=-0.048059265540188849 0.06036588533776735 -0.030072544599413102 0.030990903589822205 0.026560568681132761 -0.051938571878065741 0.0015271190921610995 0.033770613746158619 -0.039908770322941725 0.026584849929801698 -0.017941657017813275 -0.018812929986079977 -0.0011568414139026314 0.070670836690303579 -0.012775033151309585
+leaf_weight=10.448318898677828 7.7465823441743877 8.4830420017242414 9.4921096563339216 5.9989815205335608 6.2402391731739035 8.9906333237886411 6.7452828139066687 8.4876060187816602 35.739069759845734 9.7458354085683805 52.919037282466888 67.668311461806297 8.9985922873020154 11.229458034038542
+leaf_count=42 31 34 38 24 25 36 27 34 143 39 212 271 36 45
+internal_value=-0.000245346 0.00245334 -0.00406662 0.0143054 -0.00809702 0.0287598 0.0192774 -0.00728277 0.0259668 0.0170444 -0.0110225 -0.00890511 0.0530269 -0.0297814
+internal_weight=258.933 237.255 153.057 84.1984 136.32 16.7372 75.7154 15.2329 60.4825 45.4849 126.828 120.587 14.9976 21.6778
+internal_count=1037 950 613 337 546 67 303 61 242 182 508 483 60 87
+is_linear=0
+shrinkage=0.04
+
+
+Tree=3
+num_leaves=15
+num_cat=0
+split_feature=87 79 33 88 72 60 95 12 15 52 14 30 65 53
+split_gain=11.9137 10.5659 11.7467 12.0731 10.7663 8.68363 8.59661 13.4701 7.47172 9.03668 6.50335 5.61483 4.0183 3.91278
+threshold=1.5850000000000002 0.47526524006473664 5.4583333333333348 0.57686355548965829 164.17133924969747 13.133928571428573 228.96875000000003 0.14583333333333573 -3.4499999999999953 18.645833333333339 82.937500000000014 -2.0119047619047588 0.34544552124032007 23.437500000000004
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=13 2 3 4 10 -6 8 -8 -3 -10 -2 -11 -5 -1
+right_child=1 6 -4 12 5 -7 7 -9 9 11 -12 -13 -14 -15
+leaf_value=-0.046319955261748876 0.037448948902587834 -0.0088284694187992091 -0.057678550882037501 0.059995488602543341 -0.019214067900304579 0.0032492412381891801 0.018976181265562397 -0.053115091799964251 -0.018039785729919627 0.013382514787688078 -0.0088821137810651384 0.041942269689724629 0.013681980687733714 -0.012271034609450827
+leaf_weight=10.407825455069544 13.739773482084276 11.737559467554091 6.2349889278411856 5.9960742145776731 66.626564428210258 46.927813142538071 9.7444915026426333 7.219090297818183 6.492861956357955 16.732775956392288 7.4898996800184241 32.22684919834137 5.9935915470123291 11.223179444670675
+leaf_count=42 55 47 25 24 267 188 39 29 26 67 30 129 24 45
+internal_value=-0.000235931 0.00235599 -0.00390538 -0.00162108 -0.00504269 -0.00993082 0.0137405 -0.0117033 0.0201643 0.0263011 0.0211032 0.0321815 0.0368435 -0.0286538
+internal_weight=258.793 237.162 153.009 146.774 134.784 113.554 84.1536 16.9636 67.19 55.4525 21.2297 48.9596 11.9897 21.631
+internal_count=1037 950 613 588 540 455 337 68 269 222 85 196 48 87
+is_linear=0
+shrinkage=0.04
+
+
+Tree=4
+num_leaves=19
+num_cat=0
+split_feature=87 40 75 64 80 66 15 15 61 64 88 17 95 39 81 63 59 33
+split_gain=11.0085 10.3158 11.8546 12.6055 10.3939 11.5844 9.67074 10.8155 9.0703 7.92497 7.91682 7.84355 6.80908 5.80185 4.70535 3.79881 3.16026 2.99516
+threshold=1.5850000000000002 11.267857142857144 0.4095454545454546 0.35791741982096692 165.00000000000003 1.0000000180025095e-35 -9.1071428571428523 -3.725000000000001 12.690476190476192 0.33306045819490598 0.51341535239840341 -3.8124999999999996 225.46875000000003 0.33333333333333331 1.7350000000000001 0.4972961247664654 21.775000000000002 -1.0000000180025095e-35
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=15 11 3 8 5 17 12 -8 -3 -10 -5 -2 -6 -12 -13 -1 -17 -4
+right_child=1 2 4 10 6 -7 7 -9 9 -11 13 14 -14 -15 -16 16 -18 -19
+leaf_value=-0.00040554144175779727 0.012283500305906152 -0.058979450937986018 0.078347880748130691 -0.01274589698312884 0.010508267343845815 0.0014292549509687211 -0.030425427623467446 0.0073372268956942068 0.014443127755364691 -0.032407221257139643 0.0078896532861558941 -0.013267174082330087 0.063584791906166116 0.060934134607739728 -0.049547993082610223 -0.054100670196884616 -0.017902921750126199 0.042409147472346274
+leaf_weight=5.95706579089165 9.2431617081165296 9.4672348201274854 5.9933577626943579 11.224958077073099 7.9917045235633832 10.236197039484976 13.982299685478209 91.852746203541756 9.9857960343360919 13.705725058913229 6.9919697046279889 11.458065599203112 7.4933722615242004 6.2467137277126312 11.419983848929403 8.6485812216997129 6.9683696925640097 9.7404364198446292
+leaf_count=24 37 38 24 45 32 41 56 368 40 55 28 46 30 25 46 35 28 39
+internal_value=-0.000227018 0.00226278 0.00556662 -0.00981529 0.0115843 0.0345507 0.00666807 0.00234825 -0.0258849 -0.0126602 0.0119659 -0.0188136 0.0361925 0.0329189 -0.0313774 -0.0275824 -0.037949 0.056099
+internal_weight=258.608 237.034 204.913 57.6224 147.29 25.97 121.32 105.835 33.1588 23.6915 24.4636 32.1212 15.4851 13.2387 22.878 21.574 15.617 15.7338
+internal_count=1037 950 821 231 590 104 486 424 133 95 98 129 62 53 92 87 63 63
+is_linear=0
+shrinkage=0.04
+
+
+Tree=5
+num_leaves=16
+num_cat=0
+split_feature=33 88 55 55 17 54 73 52 77 17 41 97 29 62 40
+split_gain=15.351 13.8158 14.9232 12.5185 11.4912 11.3671 8.05265 14.2571 9.45676 11.7484 10.6395 4.12203 3.9043 3.69138 2.1447
+threshold=5.4583333333333348 0.54438855792157115 24.062500000000004 21.387500000000003 -9.4642857142857064 26.312500000000004 0.53494186046511638 25.387500000000003 2.0850000000000004 3.0625000000000004 12.775000000000002 0.7544642857142777 35.562500000000007 0.5081756463571766 12.803571428571431
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 4 3 -3 11 13 7 12 9 -8 -10 -1 -6 -4 -5
+right_child=-2 2 5 14 6 -7 8 -9 10 -11 -12 -13 -14 -15 -16
+leaf_value=-0.019289747362067435 -0.049291431039616411 0.0079530049109373772 -0.0023167773542189392 0.049152011733235204 0.016609632632338327 0.040013888589411864 0.013951234712260528 -0.0188765863308245 -0.039607282005252709 -0.012366184034748687 -0.0024271531554327401 -0.063622619627354979 0.056973143291589742 -0.043118301029727156 0.079727872448937878
+leaf_weight=6.9703347086906415 10.684137105941771 11.479128912091257 6.2386636584997204 7.7240137755870801 6.2296538949012819 5.9881500154733649 54.543849483132362 10.221605300903319 23.669574245810509 54.01922245323658 25.669763669371605 6.4709125310182571 9.9719207286834699 8.2252761721611005 6.9943185448646545
+leaf_count=28 43 46 25 31 25 24 219 41 95 217 103 26 40 33 28
+internal_value=-0.00235947 -0.000307937 0.0192731 0.0392628 -0.00492675 -0.00633208 -0.00232303 0.018115 -0.0057431 0.000856114 -0.0202636 -0.0406326 0.041453 -0.0255196 0.063682
+internal_weight=255.101 244.416 46.6496 26.1975 197.767 20.4521 184.326 26.4232 157.902 108.563 49.3393 13.4412 16.2016 14.4639 14.7183
+internal_count=1024 981 187 105 794 82 740 106 634 436 198 54 65 58 59
+is_linear=0
+shrinkage=0.04
+
+
+Tree=6
+num_leaves=16
+num_cat=0
+split_feature=60 62 73 75 86 9 86 68 9 75 55 17 12 53 82
+split_gain=10.7843 10.6542 9.72935 12.6928 12.2359 16.8146 10.0524 12.101 8.66024 8.63902 8.35887 7.20778 6.43585 4.33555 3.6338
+threshold=15.225000000000001 0.4697988539447821 0.53158244680851074 0.64508064516129038 1.7450000000000003 -8.3333333333333233 1.4450000000000001 207.25000000000003 -37.987012987012982 0.61348484848484863 24.291666666666668 -2.7083333333333353 3.2678571428571463 22.387500000000003 1.8350000000000002
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 11 4 6 -3 -6 7 -4 -5 -8 13 -1 -10 -2 -13
+right_child=10 2 3 8 5 -7 9 -9 12 -11 -12 14 -14 -15 -16
+leaf_value=-0.014255420135607853 0.023310237479360944 0.060688099681206698 0.047635605094340575 -0.022508370276938035 0.03702793647430791 -0.038866757036159119 -0.017236539926759407 -0.026749878847924364 0.026448512176737455 -0.054467609884275854 -0.007621975235864803 0.052597905023238606 -0.014975239364821315 0.067546521320461253 0.012566451021375784
+leaf_weight=6.2201643437147167 8.2134438902139681 6.9778638184070614 7.975793316960333 11.688230097293852 9.2276621013879812 9.4580885171890223 113.23386019468307 6.2343348562717438 27.121811106801033 10.934748843312262 8.4812200069427472 9.2266680598258954 7.7061219811439505 6.2366772443056098 5.9792356044054022
+leaf_count=25 33 28 32 47 37 38 455 25 109 44 34 37 31 25 24
+internal_value=-0.00226718 -0.00485385 -0.00758834 -0.0107917 0.0154908 -0.00138736 -0.0168681 0.0150009 0.00728451 -0.0205152 0.0239009 0.0220185 0.017283 0.0424026 0.0368568
+internal_weight=254.916 231.985 210.559 184.895 25.6636 18.6858 138.379 14.2101 46.5162 124.169 22.9313 21.4261 34.8279 14.4501 15.2059
+internal_count=1024 932 846 743 103 75 556 57 187 499 92 86 140 58 61
+is_linear=0
+shrinkage=0.04
+
+
+Tree=7
+num_leaves=18
+num_cat=0
+split_feature=89 55 54 8 43 96 98 40 90 55 37 97 49 80 65 97 62
+split_gain=10.4246 11.2262 10.7967 9.95568 11.3883 8.90539 8.65133 12.0582 11.6055 8.30861 8.22307 8.46564 6.54104 5.03193 4.78896 4.43026 4.16993
+threshold=0.45561144207842896 24.062500000000004 26.387500000000003 31.666666666666668 0.45725155221122971 175.77083333333337 -6.2083333333333348 11.162500000000001 0.19645540169586981 21.387500000000003 2.3541666666666674 1.7812500000000002 0.71927164205124738 212.00000000000003 0.35922103320833165 1.0312500000000002 0.50486813817504161
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 9 16 5 -5 -2 10 14 -9 -1 11 -6 -12 -7 -8 -11 -3
+right_child=3 2 -4 4 6 13 7 8 -10 15 12 -13 -14 -15 -16 -17 -18
+leaf_value=0.0056796349867628713 0.0048498008748587788 0.0010948092386472363 0.038285447553195809 0.03821577456306921 0.045277568585778402 -0.075491676385977521 -0.0073319216517205438 -0.028247542141635638 0.013897886134041438 0.075581548081493269 -0.059494968657228614 -0.018282852479456907 -0.017519335700108753 -0.030147268708022427 -0.056245855074949898 0.032607041143986076 -0.041584861624048911
+leaf_weight=11.720010221004488 8.2118753790855425 5.9827445000410107 5.9779978692531577 10.210737749934195 6.474472910165785 5.959468916058543 5.9542931914329511 12.197263866662977 73.146875634789467 6.4630497843027106 6.7146378159523001 6.953786626458168 51.473725467920303 11.417679086327551 6.9297584295272827 9.4506065398454648 9.4453652203083021
+leaf_count=47 33 24 24 41 26 24 24 49 294 26 27 28 207 46 28 38 38
+internal_value=-0.00217862 0.0143933 -0.00735136 -0.00613051 -0.00281263 -0.0294766 -0.00527918 0.00242922 0.00787452 0.0312376 -0.0158519 0.012363 -0.0223631 -0.0456981 -0.0336406 0.0500604 -0.0250345
+internal_weight=254.684 49.0398 21.4061 205.645 180.056 25.589 169.845 98.2282 85.3441 27.6337 71.6166 13.4283 58.1884 17.3771 12.8841 15.9137 15.4281
+internal_count=1024 197 86 827 724 103 683 395 343 111 288 54 234 70 52 64 62
+is_linear=0
+shrinkage=0.04
+
+
+Tree=8
+num_leaves=16
+num_cat=0
+split_feature=33 88 55 55 17 54 27 62 59 60 11 86 27 15 39
+split_gain=14.0335 11.5183 12.3907 10.6473 9.85957 9.50449 8.91174 9.57804 8.94568 7.22924 4.21001 3.63151 3.58218 2.92798 2.2831
+threshold=5.4583333333333348 0.54438855792157115 24.062500000000004 21.535714285714288 -9.4642857142857064 26.312500000000004 -7.9791666666666661 0.47163958632520975 19.162500000000005 15.225000000000001 114.68750000000001 1.885 -0.06770833333333344 -1.0000000180025095e-35 -0.11249999999999999
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 4 3 12 11 10 8 13 -6 -9 -4 -1 -3 -8 -5
+right_child=-2 2 5 14 6 -7 7 9 -10 -11 -12 -13 -14 -15 -16
+leaf_value=-0.017506959694980919 -0.047093096159148848 -0.013030607518081373 -0.0050211407760301866 0.041861979165786371 -0.0054470000340854632 0.036839736021523913 0.0084047253587021115 -0.0053865642716596834 -0.068322690853454923 0.024130364791092217 -0.048932153004977219 -0.059267051521897846 0.029896871945299459 0.042249585564822965 0.074866216000504499
+leaf_weight=6.9434050768613798 10.625629082322119 5.9767347723245621 8.4471292942762393 5.9510868340730667 8.7058147490024549 5.9711179584264746 6.7232442200183895 137.19698540866375 6.1981060206890097 14.698398649692534 5.9571634531021109 6.405640184879303 6.4850186705589312 10.441370263695715 7.6831773668527585
+leaf_count=28 43 24 34 24 35 24 27 552 25 59 24 26 26 42 31
+internal_value=-0.00209418 -0.000132847 0.017783 0.0360337 -0.0043524 -0.00559187 -0.00194377 0.000670223 -0.0315952 -0.00253031 -0.0231814 -0.0375459 0.00930858 0.0289928 0.0604605
+internal_weight=254.41 243.784 46.4714 26.096 197.313 20.3754 183.964 169.06 14.9039 151.895 14.4043 13.349 12.4618 17.1646 13.6343
+internal_count=1024 981 187 105 794 82 740 680 60 611 58 54 50 69 55
+is_linear=0
+shrinkage=0.04
+
+
+Tree=9
+num_leaves=16
+num_cat=0
+split_feature=33 88 55 55 54 8 43 98 37 50 96 80 11 38 39
+split_gain=13.0015 10.6389 11.4582 9.90804 8.77538 8.77091 9.15232 8.52658 12.059 8.78208 8.37899 5.06162 3.90198 3.4714 2.1433
+threshold=5.4583333333333348 0.54438855792157115 24.062500000000004 21.535714285714288 26.312500000000004 31.666666666666668 0.45725155221122971 -6.2083333333333348 3.0625000000000004 0.77107730652069451 175.77083333333337 212.00000000000003 114.68750000000001 3.0625000000000004 -0.11249999999999999
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 5 3 13 12 10 -7 9 -9 -8 -1 -12 -4 -3 -5
+right_child=-2 2 4 14 -6 6 7 8 -10 -11 11 -13 -14 -15 -16
+leaf_value=0.0073464817079793203 -0.045435105019414168 -0.011342813791158599 -0.0048216877875364326 0.040315188023492481 0.035433511001246025 0.035818050318993391 -0.0019489232180927723 -0.01869102791191958 0.013448791274373359 -0.030954345333154155 -0.072293858788171919 -0.026294701048497598 -0.047141285128800781 0.030922033964920961 0.072368292940394013
+leaf_weight=7.9585580676794079 10.573872312903402 6.4793082326650637 8.4447395205497759 5.9326046109199524 5.9599837511777869 10.172822326421736 40.264701783657074 25.803554385900497 67.645555391907692 28.539862290024757 5.9069683849811581 10.872051388025282 5.9365375787019721 5.9781518280506134 7.6314401328563672
+leaf_count=32 43 26 34 24 24 41 162 104 272 115 24 44 24 24 31
+internal_value=-0.0020131 -0.00012773 0.0171133 0.0346948 -0.00537778 -0.00418193 -0.000986385 -0.00329391 0.00457421 -0.0139803 -0.0264556 -0.0424885 -0.0222911 0.00893946 0.058349
+internal_weight=254.101 243.527 46.3628 26.0215 20.3413 197.164 172.426 162.254 93.4491 68.8046 24.7376 16.779 14.3813 12.4575 13.564
+internal_count=1024 981 187 105 82 794 694 653 376 277 100 68 58 50 55
+is_linear=0
+shrinkage=0.04
+
+
+Tree=10
+num_leaves=22
+num_cat=0
+split_feature=75 87 95 14 11 36 58 58 8 58 40 54 31 17 32 95 54 90 30 18 46
+split_gain=10.0606 13.2442 13.2354 7.28198 9.27874 9.24179 8.65882 8.65277 7.77526 9.89423 8.92987 8.43675 7.69243 6.47202 5.91656 6.71204 5.41747 5.66364 4.6817 4.44902 4.42172
+threshold=0.58007633587786267 1.5850000000000002 229.28125000000003 117.31250000000001 115.18750000000001 0.59375000000000011 24.803571428571434 24.354166666666668 42.261904761904766 17.062500000000004 13.35416666666667 20.062500000000004 24.562500000000004 5.4375000000000009 20.145833333333339 220.46875000000003 20.775000000000002 0.19788825188533934 0.60416666666666796 -4.3541666666666705 0.35905136104149266
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=3 18 13 4 8 7 19 -5 11 -10 -11 -1 -13 16 -15 -16 -3 -18 -2 -6 -4
+right_child=1 2 20 5 6 -7 -8 -9 9 10 -12 12 -14 14 15 -17 17 -19 -20 -21 -22
+leaf_value=0.016260010087575247 -0.00081200744809965017 0.009281923181331737 0.0032509448060061706 -0.025493613615531322 -0.074632317496072326 0.049617586690472636 0.0010470202171259946 0.03284274215952835 -0.029153960626547033 0.0012674975757078009 0.038103679086545161 -0.037991918317932111 0.0028048182430481369 0.031585379031769001 -0.038777627179031486 0.020611308349097066 0.013481360235318833 0.054225087511587569 -0.04021991897983087 -0.030101771519433589 -0.04216852229361847
+leaf_weight=9.4118207991123182 10.595016002655031 9.211836025118826 7.6921787559986097 10.383948802948003 6.9398950040340432 7.9301784783601752 7.663398250937461 6.6885293126106253 11.645323514938353 37.428400799632072 14.651625692844389 25.72077003121376 10.378917679190634 10.19868426024914 6.2205115109682065 5.9642188549041748 7.1979017257690456 22.59254564344883 8.8545045703649503 7.4363927543163308 6.1885804086923599
+leaf_count=38 43 37 31 42 28 32 31 27 47 151 59 104 42 41 25 24 29 91 36 30 25
+internal_value=0.000384931 0.0106717 0.0182752 -0.00584956 -0.00961775 0.0139354 -0.0332929 -0.00263903 -0.00484104 0.00417752 0.0116306 -0.0174689 -0.0262626 0.0262515 0.00910688 -0.00970775 0.0360908 0.0443807 -0.0187527 -0.0515981 -0.0169988
+internal_weight=250.995 94.716 75.2665 156.279 131.277 25.0027 22.0397 17.0725 109.237 63.7254 52.08 45.5115 36.0997 61.3857 22.3834 12.1847 39.0023 29.7904 19.4495 14.3763 13.8808
+internal_count=1013 382 303 631 530 101 89 69 441 257 210 184 146 247 90 49 157 120 79 58 56
+is_linear=0
+shrinkage=0.04
+
+
+Tree=11
+num_leaves=23
+num_cat=0
+split_feature=46 34 52 26 15 25 38 25 38 45 51 29 31 85 45 97 77 48 50 89 35 15
+split_gain=8.75369 11.3656 14.889 8.46246 7.41306 7.3335 8.41222 8.91166 7.82615 7.37315 7.16896 7.00775 6.83601 6.4889 6.43695 6.32157 6.2568 5.61316 5.35895 4.7914 4.5558 2.75508
+threshold=0.38135121729750621 6.8875000000000011 22.775000000000002 7.1406250000000009 -7.5624999999999991 2.0520833333333335 2.6904761904761911 13.989583333333334 3.0625000000000004 0.026346315240645454 0.014637337657707453 41.401785714285722 17.354166666666668 -2.9999999999999996 -0.03868421822005879 -3.0312499999999996 1.7550000000000001 0.050581642342345606 0.78802449932964647 0.44915558749550849 7.4226190476190483 3.7857142857142851
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 5 3 15 20 16 9 8 -8 12 11 18 -7 -5 -6 -3 -1 -12 -2 -16 -4 -17
+right_child=10 2 4 13 14 6 7 -9 -10 -11 17 -13 -14 -15 19 21 -18 -19 -20 -21 -22 -23
+leaf_value=-0.0054894704946171517 0.0015186659314490275 0.012422457986275524 0.045080183146636456 -0.016969101137900868 -0.040094377162748857 0.019099728305053802 0.028826737553279212 0.048811854341376415 -0.010159784240800534 -0.052368685379215477 -0.057749287922771578 0.032139891068220787 -0.025625732807283655 0.02903959599951628 0.028393278510576315 0.063703565821716004 -0.055469403457085856 -0.0080914581224991559 -0.047345864671010984 -0.006544736689285552 0.00014063060048828728 0.032655129091640721
+leaf_weight=7.6778917312622097 9.1392136514186877 8.1994599252939242 8.1893729716539365 8.9037519246339816 7.9227678179740897 9.4139631241560036 11.599057033658026 7.4388175308704367 28.433443784713745 7.6398711800575247 9.4042548984289152 6.4537621885538092 13.044003814458845 10.920071274042128 7.412743777036666 14.361867994070055 8.3833764642477018 5.9441701322793952 5.9151509106159201 41.112754985690117 6.4537106007337561 6.7087357491254798
+leaf_count=31 37 33 33 36 32 38 47 30 115 31 38 26 53 44 30 58 34 24 24 166 26 27
+internal_value=0.000369477 0.00347289 0.0116128 0.0285547 -8.68246e-05 -0.0069756 -0.00188168 0.00860705 0.00113621 -0.0184248 -0.0176344 -0.00273177 -0.00687765 0.00837506 -0.00666555 0.0422218 -0.0315771 -0.0385177 -0.0176812 -0.00120761 0.0252738 0.053818
+internal_weight=250.672 213.816 120.185 49.0939 71.0914 93.6304 77.5692 47.4713 40.0325 30.0978 36.8566 21.5081 22.458 19.8238 56.4483 29.2701 16.0613 15.3484 15.0544 48.5255 14.6431 21.0706
+internal_count=1013 864 485 198 287 379 314 192 162 122 149 87 91 80 228 118 65 62 61 196 59 85
+is_linear=0
+shrinkage=0.04
+
+
+Tree=12
+num_leaves=23
+num_cat=0
+split_feature=75 60 11 14 27 80 97 64 82 74 61 28 51 77 17 18 26 73 77 29 17 40
+split_gain=9.16434 11.0589 9.72885 16.5355 11.7419 10.0895 9.63264 9.40553 6.81505 6.89416 6.69885 7.87536 6.2381 5.78129 6.43908 7.23032 5.6961 5.53399 5.51269 7.0191 3.79526 2.70316
+threshold=0.40070422535211275 12.937500000000002 115.68750000000001 116.31250000000001 -0.9583333333333337 166.00000000000003 7.8229166666666581 0.35791741982096692 2.3750000000000004 0.68460526315789483 11.312500000000002 43.669642857142868 -0.00055870543754424991 2.4850000000000008 2.6875000000000004 11.267857142857148 3.0104166666666674 0.54977477477477488 3.5300000000000007 41.937500000000007 -3.0624999999999996 13.062500000000002
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=7 8 4 17 5 -3 16 13 9 10 -2 -12 -7 -1 15 21 -6 -4 19 20 -9 -15
+right_child=1 2 3 -5 6 12 -8 18 -10 -11 11 -13 -14 14 -16 -17 -18 -19 -20 -21 -22 -23
+leaf_value=-0.054673857447064877 0.031426635667739504 0.027443307507820841 -0.0071693293359852243 0.038925915934784942 0.050420363552369514 -0.055974948859624327 -0.015254363709585871 -0.00096046171680576385 -0.04185499138480625 -0.033145360136453486 -0.0080473225873038019 0.03965940078614745 0.00028714853340948784 -0.057615503467417908 0.017966063373814029 0.0078546298795259799 0.022851321189234875 -0.052721746825391283 0.037758480535269187 0.02828748068011893 -0.046251148347414762 -0.023260226786483273
+leaf_weight=8.6124199628829938 10.635522291064261 9.4400324672460574 8.4194629490375572 8.1747892647981626 24.48761148750782 6.1720191240310669 6.4190221130847922 5.9309897720813787 7.6241378188133231 10.108165323734282 52.924647763371468 6.1832769215106955 6.4464221149682981 8.5726141929626518 6.4193207621574393 6.403973162174224 23.496750026941299 8.652211129665373 6.4387345761060706 6.4527361392974845 5.9104709476232546 6.4002304375171652
+leaf_count=35 43 38 34 33 99 25 26 24 31 41 214 25 26 35 26 26 95 35 26 26 24 26
+internal_value=0.000354686 0.00470563 0.0136746 -0.00785498 0.0207833 -0.00383352 0.0307644 -0.013108 -0.00572256 -0.00227267 0.00220181 -0.00305672 -0.0272322 -0.0260387 -0.0171663 -0.0277163 0.0369205 -0.0302561 0.00592675 -0.00527659 -0.0235666 -0.0429301
+internal_weight=250.326 189.184 101.708 25.2465 76.4619 22.0585 54.4034 61.1415 87.4758 79.8516 69.7434 59.1079 12.6184 36.4086 27.7961 21.3768 47.9844 17.0717 24.7329 18.2942 11.8415 14.9728
+internal_count=1013 765 411 102 309 89 220 248 354 323 282 239 51 148 113 87 194 69 100 74 48 61
+is_linear=0
+shrinkage=0.04
+
+
+Tree=13
+num_leaves=19
+num_cat=0
+split_feature=75 87 95 39 88 58 95 57 51 48 58 32 63 24 83 55 97 82
+split_gain=8.61924 11.4411 11.6705 8.28079 6.48928 6.06533 8.08152 14.8066 8.57749 8.46636 7.40152 6.03526 6.41459 8.82896 6.7274 5.49578 4.98309 3.77165
+threshold=0.58007633587786267 1.5850000000000002 229.28125000000003 -0.08571428571428534 0.57686355548965829 16.437500000000004 171.09375000000003 38.687500000000007 -0.016939089932731747 -0.033449118040512087 27.387500000000003 17.062500000000004 0.48324752364570916 -1.0000000180025095e-35 0.52167307176691413 21.937500000000004 3.2187500000000004 1.6850000000000003
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=4 15 11 -4 5 -1 8 9 -7 -8 -9 -3 13 -13 -14 -2 -17 -10
+right_child=1 2 3 -5 -6 6 7 10 17 -11 -12 12 14 -15 -16 16 -18 -19
+leaf_value=-0.037191415145792946 -0.049107836359544479 0.057010861992900341 0.011593508527805042 -0.050683110628723223 0.024122659092291082 -0.013516688468798235 0.0070009506232722408 -0.0048723531932253544 0.015903788969995617 -0.045659362164178104 0.041619476315647989 -0.040633960200292647 0.017460987223942896 0.023949802445685821 0.054172151049742406 0.018705900435433812 -0.030600473896497015 0.053826338845108651
+leaf_weight=10.358175262808798 6.0601196587085751 7.9332039654254904 7.6448924392461777 6.1759819239377958 11.035771340131758 11.594122901558878 6.1791122853755978 69.580003947019577 10.684715464711191 23.321105942130089 5.9471079260110846 5.9447444081306458 28.258737400174141 7.8707564771175367 11.133399918675421 7.4004974067211133 5.8894641548395157 6.9099283069372168
+leaf_count=42 25 32 31 25 45 47 25 282 43 95 24 24 114 32 45 30 24 28
+internal_value=0.000340314 0.00988207 0.0169604 -0.0162354 -0.00544273 -0.00769954 -0.0054235 -0.0105979 0.0131951 -0.0346291 -0.00121152 0.0244643 0.0196117 -0.00384028 0.0278367 -0.0175393 -0.00314428 0.0307971
+internal_weight=249.922 94.3118 74.9617 13.8209 155.61 144.574 134.216 105.027 29.1888 29.5002 75.5271 61.1408 53.2076 13.8155 39.3921 19.3501 13.29 17.5946
+internal_count=1013 382 303 56 631 586 544 426 118 120 306 247 215 56 159 79 54 71
+is_linear=0
+shrinkage=0.04
+
+
+Tree=14
+num_leaves=21
+num_cat=0
+split_feature=75 79 28 27 14 60 31 69 47 53 31 75 36 41 56 46 49 46 77 74
+split_gain=8.04256 13.9131 8.58147 7.46144 10.122 9.11597 10.0351 11.5688 9.90082 8.37289 8.31104 8.15738 7.02093 6.34993 5.18118 6.69615 5.11523 3.3449 3.22441 5.46203
+threshold=0.6718233349078887 0.6464920911223796 41.687500000000007 -2.3020833333333326 91.062500000000014 12.937500000000002 25.803571428571434 1.7083333333333337 0.37218684558476361 25.812500000000004 17.354166666666668 0.3980198019801981 -0.26190476190476181 12.775000000000002 40.062500000000007 0.37106571647400344 0.76572220694348403 0.35494543794947025 1.4850000000000001 0.49543388429752072
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=3 18 12 4 13 6 14 -8 10 -10 -7 -12 -3 -1 15 -5 -16 -6 19 -2
+right_child=1 2 -4 5 17 8 7 -9 9 -11 11 -13 -14 -15 16 -17 -18 -19 -20 -21
+leaf_value=-0.019711473750247656 0.056394721780793459 -0.014592747921604247 -0.045243698355551337 0.0010942635313375348 -0.026082382729623245 0.059046481579424839 0.042087030208466859 -0.025395196611899901 -0.0380827165006535 0.012578046288920864 -0.012429649451340766 0.020979301067090405 0.03089449715034762 0.032768838321915822 -0.061831820327718327 -0.032477187860471046 -0.018967296365290393 -0.062065664493685058 0.060078921525471347 0.0051456786696745154
+leaf_weight=8.626388296484949 5.9154238402843493 10.863973572850233 6.1918527483940116 30.794128924608231 9.0536976456642169 6.6757322102785102 11.092378646135332 6.415662854909896 11.35324338078499 9.6619694828987104 16.008781462907791 43.380531519651413 10.852814644575117 6.4449361413717261 6.8486602157354382 13.751119881868361 12.741591066122053 7.6055790930986396 7.6382495164871207 7.6053119897842407
+leaf_count=35 24 44 25 125 37 27 45 26 46 39 65 176 44 26 28 56 52 31 31 31
+internal_value=0.000326808 0.0148417 -0.00370442 -0.00322617 -0.0210218 0.000120512 -0.00948172 0.0173588 0.00912325 -0.0147909 0.0167303 0.0119737 0.00813919 0.00273063 -0.0168088 -0.00926924 -0.0339525 -0.0425101 0.0393039 0.0275675
+internal_weight=249.522 49.0676 27.9086 200.454 31.7306 168.724 81.6435 17.508 87.0803 21.0152 66.065 59.3893 21.7168 15.0713 64.1355 44.5452 19.5903 16.6593 21.159 13.5207
+internal_count=1013 199 113 814 129 685 332 71 353 85 268 241 88 61 261 181 80 68 86 55
+is_linear=0
+shrinkage=0.04
+
+
+Tree=15
+num_leaves=14
+num_cat=0
+split_feature=86 40 27 10 41 31 73 65 28 74 14 97 65
+split_gain=9.19077 7.28223 7.35402 9.11593 7.22847 7.50822 7.14398 7.51306 6.94962 5.72956 5.5869 4.91206 4.48842
+threshold=1.425 10.937500000000002 -10.947916666666666 84.062500000000014 13.645833333333334 15.29166666666667 0.5344873150105709 0.32491602042266449 39.687500000000007 0.47029411764705881 85.535714285714292 -0.42708333333332854 0.35541085304317482
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=8 11 10 4 5 -4 9 -8 -1 -5 -3 -2 -13
+right_child=1 2 3 6 -6 -7 7 -9 -10 -11 -12 12 -14
+leaf_value=0.059592270356515986 0.0053735337050535084 0.0014536342489078382 -0.0042774365987278294 0.047077753667467796 -0.014197369069938693 0.036529368742735643 0.01583862591245707 -0.0087913938399981923 0.0061247756213370069 0.0052192588836833601 -0.050790366696786798 -0.012402789325272627 -0.059610908501483095
+leaf_weight=7.3100549280643454 6.1067151725292232 5.9317886233329755 9.6296757310628873 7.8829693347215679 8.6421001106500608 28.761566951870918 23.91489639878273 115.60252341628075 8.3125372529029828 15.558673441410063 7.3123210966587067 5.9148542433977109 7.0790839940309525
+leaf_count=30 25 24 39 32 35 117 97 469 34 63 30 24 29
+internal_value=0.00140631 -0.00051071 0.00151755 0.00334081 0.0188538 0.0262938 -0.00113655 -0.00456952 0.0311431 0.0192955 -0.0273913 -0.0242158 -0.0381217
+internal_weight=257.96 242.337 223.237 209.992 47.0333 38.3912 162.959 139.517 15.6226 23.4416 13.2441 19.1007 12.9939
+internal_count=1048 984 906 852 191 156 661 566 64 95 54 78 53
+is_linear=0
+shrinkage=0.04
+
+
+Tree=16
+num_leaves=13
+num_cat=0
+split_feature=33 88 64 14 97 55 33 27 95 11 62 89
+split_gain=8.94152 9.44973 8.34757 9.96923 9.2269 7.77034 6.84612 6.71789 8.91623 11.1245 5.59099 2.07466
+threshold=5.4583333333333348 0.5709995709995711 0.32539627952456907 83.535714285714292 -1.5982142857142916 24.062500000000004 0.3184523809523796 -12.94270833333333 170.79017857142858 87.645833333333357 0.50771095194186133 0.48370246267843525
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 2 3 4 -1 -3 11 -4 10 -10 -9 -5
+right_child=-2 5 7 6 -6 -7 -8 8 9 -11 -12 -13
+leaf_value=-0.021346605099593578 -0.036738482853078236 0.058873571365345455 -0.029645258704030009 -0.03604840849327056 0.042575470200724393 0.0048157514196816237 -0.0070588968786982603 0.037451850608501855 -0.041717482942480864 0.0036108240465800787 0.0091615077619154172 -0.067942279025163504
+leaf_weight=7.6162292957305908 9.497162461280821 8.4247576445341128 9.057781442999838 6.4219828844070452 6.8739977478981 8.594713091850279 9.099840894341467 19.09737765789032 9.280805364251135 130.09927693009377 26.950699493288994 6.6345582008361816
+leaf_count=31 39 35 37 26 28 35 37 78 38 528 109 27
+internal_value=0.00135171 0.00280948 0.00069135 -0.0168207 0.0089773 0.0315748 -0.0336925 0.00399111 0.00563418 0.000592579 0.0208943 -0.052255
+internal_weight=257.649 248.152 231.133 36.6466 14.4902 17.0195 22.1564 194.486 185.428 139.38 46.0481 13.0565
+internal_count=1048 1009 939 149 59 70 90 790 753 566 187 53
+is_linear=0
+shrinkage=0.04
+
+
+Tree=17
+num_leaves=12
+num_cat=0
+split_feature=33 88 55 27 10 32 31 60 75 90 14
+split_gain=8.28401 8.76598 7.29837 6.5019 6.36672 9.86493 7.51301 7.17497 6.93615 6.2403 5.35126
+threshold=5.4583333333333348 0.5709995709995711 24.062500000000004 -12.94270833333333 84.062500000000014 20.062500000000004 25.803571428571434 12.937500000000002 0.42318766937669378 0.19774467682950328 85.535714285714292
+decision_type=2 2 2 2 2 2 2 2 2 2 2
+left_child=1 3 -3 10 5 8 7 -6 -5 -8 -1
+right_child=-2 2 -4 4 6 -7 9 -9 -10 -11 -12
+leaf_value=5.5780973020133532e-06 -0.035467582222402753 0.05716359984226644 0.004623749836194309 -0.010644706886582317 -0.01582380049665728 -0.034391445298106116 0.046794179848204068 0.0026044549279971439 0.028201993083561465 0.0052060024656404988 -0.051579011297576027
+leaf_weight=6.1612475216388685 9.4450326114892942 8.3315776139497775 8.5935685932636243 9.1481379419565183 59.708019092679024 5.8809057772159568 8.1617092192173022 77.918728813529015 37.500212237238884 19.722670719027519 6.7347901910543442
+leaf_count=25 39 35 35 37 243 24 33 316 153 80 28
+internal_value=0.00129938 0.00270042 0.030487 0.000663966 0.00229624 0.0144291 -0.00155443 -0.00539046 0.0205838 0.0173788 -0.0269338
+internal_weight=257.307 247.862 16.9251 230.936 218.04 52.5293 165.511 137.627 46.6484 27.8844 12.896
+internal_count=1048 1009 70 939 886 214 672 559 190 113 53
+is_linear=0
+shrinkage=0.04
+
+
+Tree=18
+num_leaves=8
+num_cat=0
+split_feature=33 88 55 11 17 87 45
+split_gain=7.67811 8.13711 6.86921 6.16429 9.02438 5.74349 6.3002
+threshold=5.4583333333333348 0.5709995709995711 24.062500000000004 74.354166666666671 -10.687499999999998 2.1450000000000005 -0.0034592463243838995
+decision_type=2 2 2 2 2 2 2
+left_child=1 3 -3 -1 -5 6 -6
+right_child=-2 2 -4 4 5 -7 -8
+leaf_value=0.036528500712599402 -0.034255437987614025 0.0555735632038485 0.004439425576339767 -0.038357932926460371 -0.0070697236803132311 0.030356748335144887 0.0070235502949047429
+leaf_weight=7.4107095897197715 9.3892168849706632 8.2292238324880618 8.5923809558153135 9.6656254380941373 105.90707743167877 10.260427355766295 97.451314657926559
+leaf_count=30 39 35 35 40 431 42 396
+internal_value=0.00124942 0.00259625 0.0294545 0.000637822 -0.000553374 0.00115717 -0.00031609
+internal_weight=256.906 247.517 16.8216 230.695 223.284 213.619 203.358
+internal_count=1048 1009 70 939 909 869 827
+is_linear=0
+shrinkage=0.04
+
+
+Tree=19
+num_leaves=12
+num_cat=0
+split_feature=33 86 64 12 27 95 11 49 62 29 63
+split_gain=7.11864 7.56899 6.11087 12.4985 5.73268 8.29302 10.1577 5.48698 5.06855 4.93802 3.11264
+threshold=5.4583333333333348 1.4150000000000003 0.32539627952456907 1.9375000000000002 -12.94270833333333 170.79017857142858 87.645833333333357 0.77175549922512843 0.54605872496633345 41.401785714285722 0.51856200631031568
+decision_type=2 2 2 2 2 2 2 2 2 2 2
+left_child=1 9 3 8 -4 7 -7 -6 10 -1 -3
+right_child=-2 2 4 -5 5 6 -8 -9 -10 -11 -12
+leaf_value=0.054127893054378734 -0.033097093119392906 -0.024347971534982155 -0.027558678245584001 0.020697790803193339 0.012679398061121673 -0.0402735013491324 0.0031588930417813959 0.046340548831502577 0.0016157647003835103 0.0053158736723644484 -0.056291390595480988
+leaf_weight=7.2425345033407194 9.3303139358758909 10.320196986198431 8.9888450950384122 11.517354950308798 36.484531104564667 9.2175567746162397 131.94763413071632 9.837190628051756 6.3723442256450644 6.1165111809968948 9.2601860165595991
+leaf_count=31 39 42 37 47 149 38 536 40 26 25 38
+internal_value=0.0012009 0.0024949 0.00082268 -0.0139809 0.00364588 0.00514195 0.000322921 0.0198279 -0.0293706 0.031779 -0.039455
+internal_weight=256.635 247.305 233.946 37.4701 196.476 187.487 141.165 46.3217 25.9527 13.359 19.5804
+internal_count=1048 1009 953 153 800 763 574 189 106 56 80
+is_linear=0
+shrinkage=0.04
+
+
+Tree=20
+num_leaves=15
+num_cat=0
+split_feature=60 18 88 26 36 31 9 24 61 35 75 60 95 51
+split_gain=8.03818 7.72948 8.40414 12.0656 10.8001 9.64736 8.20128 6.93288 5.91815 6.68838 6.79855 4.79664 4.70914 4.49622
+threshold=15.225000000000001 -0.29166666666667135 0.56584311806914556 14.937500000000002 -0.83124999999999971 19.645833333333339 16.515151515151516 -1.0000000180025095e-35 15.645833333333334 8.5669642857142865 0.58007633587786267 15.775000000000002 222.78125000000003 0.0018411019890782001
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 6 3 4 13 -6 8 -2 9 10 -1 -9 -4 -3
+right_child=7 2 12 -5 5 -7 -8 11 -10 -11 -12 -13 -14 -15
+leaf_value=-0.0089530653611645094 -0.013396078382306617 -0.012100783857722328 0.043432242412436123 -0.05470139039712181 0.021915508768684949 -0.01294489712125084 0.048027122146776596 0.063122343027819355 0.035214924114047572 -0.036143728924515048 0.011385864248782825 0.018228963324568446 -0.0045408979170662904 -0.049373438013463097
+leaf_weight=53.602775543928146 6.6217800229787853 8.524589270353319 6.1861436218023282 11.381553843617437 18.768473565578461 39.295118644833565 6.1146008819341651 6.1183906942605999 7.3963862508535376 8.3620016276836378 51.616437286138535 10.084086462855337 6.9543650448322296 13.191540747880934
+leaf_count=219 27 35 26 47 77 160 25 25 30 34 210 41 29 54
+internal_value=-0.00155888 -0.00379275 -0.0118627 -0.0161736 -0.0106771 -0.00167662 0.00283011 0.0210883 0.000545703 -0.00171195 0.00102442 0.0351816 0.0180434 -0.0347422
+internal_weight=254.218 231.394 104.302 91.1613 79.7797 58.0636 127.092 22.8243 120.978 113.581 105.219 16.2025 13.1405 21.7161
+internal_count=1039 946 428 373 326 237 518 93 493 463 429 66 55 89
+is_linear=0
+shrinkage=0.04
+
+
+Tree=21
+num_leaves=15
+num_cat=0
+split_feature=60 18 88 26 36 31 9 9 61 35 35 95 51 28
+split_gain=7.42241 7.14338 7.76759 11.245 10.0048 8.89861 7.56719 6.33462 5.44938 6.18568 6.60464 4.38569 4.18924 2.06881
+threshold=15.225000000000001 -0.29166666666667135 0.56584311806914556 14.937500000000002 -0.83124999999999971 19.645833333333339 16.515151515151516 -4.2748917748917838 15.645833333333334 8.5669642857142865 8.2678571428571441 222.78125000000003 0.0018411019890782001 41.187500000000007
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 6 3 4 12 -6 8 -2 9 10 -1 -4 -3 -9
+right_child=7 2 11 -5 5 -7 -8 13 -10 -11 -12 -13 -14 -15
+leaf_value=-0.0020580613462284694 -0.0067757984042552816 -0.011632476414499757 0.042031501598029888 -0.052911002493618228 0.021055706218397436 -0.012438211689475422 0.046156795546078516 0.022002629364403069 0.033775328851131076 -0.034815903882803013 0.034011731538430165 -0.0043576236343065185 -0.047663392508499491 0.052589999762468774
+leaf_weight=96.316321060061455 8.6104428470134753 8.5132995098829287 6.1375970840454084 11.297693848609923 18.753774255514145 39.26072384417057 6.1079912632703772 7.3507572114467603 7.4030207246541968 8.3342373967170698 8.8703934699296934 6.9569248706102371 13.119665667414663 6.8210117071866989
+leaf_count=393 35 35 26 47 77 160 25 30 30 34 36 29 54 28
+internal_value=-0.00149909 -0.00364675 -0.0114181 -0.0155653 -0.010268 -0.00161096 0.002718 0.0202838 0.000523866 -0.00164456 0.000983704 0.0173856 -0.033484 0.0367246
+internal_weight=253.854 231.072 104.04 90.9452 79.6475 58.0145 127.032 22.7822 120.924 113.521 105.187 13.0945 21.633 14.1718
+internal_count=1039 946 428 373 326 237 518 93 493 463 429 55 89 58
+is_linear=0
+shrinkage=0.04
+
+
+Tree=22
+num_leaves=18
+num_cat=0
+split_feature=75 10 73 56 97 33 54 28 63 53 73 64 38 53 14 13 63
+split_gain=6.8389 8.24825 6.33351 8.88087 6.18565 5.67783 6.55094 5.59704 6.85557 8.66603 7.65659 7.21773 11.1113 8.66033 3.97328 3.82022 2.45765
+threshold=0.71055555555555572 112.31250000000001 0.53158244680851074 39.937500000000007 -0.42708333333332854 -3.077380952380953 21.145833333333339 44.937500000000007 0.51560927336724371 25.687500000000004 0.63958726168028501 0.34495732674280544 4.3875000000000011 27.437500000000004 110.18750000000001 98.625000000000014 0.51800407176145413
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=2 5 3 15 -5 -2 -7 8 9 10 -4 12 -10 -13 -11 -1 -8
+right_child=1 -3 7 4 -6 6 16 -9 11 14 -12 13 -14 -15 -16 -17 -18
+leaf_value=0.015837814614419042 -0.0054090476665669711 -0.020413774544095844 -0.0067905346474414312 0.026068878291681773 -0.024468940768756574 0.010241531744467547 0.073552533225814301 0.020224466305667418 -0.0046266451570048392 -0.021209825690180987 -0.052758572611820695 0.0025546027891674618 -0.064146045205184979 0.052111362242983086 -0.062702945254864487 0.060247018203511145 0.036959564623549768
+leaf_weight=5.9841428995132464 7.3666127473115912 8.3540667146444303 65.92797489464283 6.133746981620793 10.522817611694332 9.2578747272491508 5.8667192012071592 11.480442628264425 29.450126886367798 6.6407066881656638 6.3565134406089774 47.05113098025322 6.0492770820856085 6.4109846800565711 8.3170198649167997 6.4289718419313431 5.8796851336956024
+leaf_count=25 30 34 271 25 43 38 24 47 121 27 26 193 25 26 34 26 24
+internal_value=-0.00144173 0.0145202 -0.00414618 0.0132275 -0.00585849 0.0248068 0.0354041 -0.00683713 -0.00860031 -0.0165676 -0.0108328 -0.000786974 -0.0147691 0.00849727 -0.0442815 0.0388381 0.0552359
+internal_weight=253.479 36.725 216.754 29.0697 16.6566 28.3709 21.0043 187.684 176.204 87.2422 72.2845 88.9615 35.4994 53.4621 14.9577 12.4131 11.7464
+internal_count=1039 150 889 119 68 116 86 770 723 358 297 365 146 219 61 51 48
+is_linear=0
+shrinkage=0.04
+
+
+Tree=23
+num_leaves=16
+num_cat=0
+split_feature=60 18 35 26 21 11 72 34 42 69 65 24 60 29 16
+split_gain=6.76622 6.44432 7.43603 8.61975 6.98342 7.45293 9.26335 8.42599 8.25952 6.4395 7.95854 6.13581 4.32375 3.78406 2.36778
+threshold=15.225000000000001 -0.29166666666667135 8.8229166666666696 14.937500000000002 0.16515151515151519 123.68750000000001 227.82000000000002 8.4687500000000018 -0.84166666666666667 8.2500000000000018 0.32491602042266449 -1.0000000180025095e-35 15.775000000000002 32.708333333333336 4.9375000000000009
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 4 3 9 5 6 7 -1 -8 10 -3 -2 -13 -5 -11
+right_child=11 2 -4 13 -6 -7 8 -9 -10 14 -12 12 -14 -15 -16
+leaf_value=0.0068377190178299978 -0.012999968486144695 0.046209360196903707 -0.047916200210550458 -0.016602574178768866 0.044382956007966268 0.041711064554847729 0.012542729748890782 -0.040858831579305734 -0.041878353739748291 -0.047809843446037739 -0.0025966166987321858 0.059424945850961183 0.016650328155874659 -0.061312735990994086 -0.01220746979923833
+leaf_weight=86.415405079722404 6.6122610569000271 5.8188596814870825 7.9874863028526297 5.9741610884666425 6.0946186929941168 6.6349345445632926 6.355574399232867 6.3623842000961295 14.977498367428778 6.0902193337678892 65.746306836605072 6.0662906020879772 10.036743447184561 6.1432460248470306 5.8692503720521927
+leaf_count=353 27 24 33 25 25 27 26 26 61 25 271 25 41 26 24
+internal_value=-0.00138606 -0.00343895 -0.0108389 -0.0077424 0.00260686 0.000498221 -0.00189808 0.00356685 -0.0256652 -0.00316857 0.00137173 0.0194426 0.0327643 -0.0392696 -0.0303376
+internal_weight=253.185 230.47 103.63 95.642 126.84 120.746 114.111 92.7778 21.3331 83.5246 71.5652 22.7153 16.103 12.1174 11.9595
+internal_count=1039 946 428 395 518 493 466 379 87 344 295 93 66 51 49
+is_linear=0
+shrinkage=0.04
+
+
+Tree=24
+num_leaves=15
+num_cat=0
+split_feature=60 18 88 27 62 9 11 72 12 48 36 24 43 95
+split_gain=6.25224 5.95135 7.10947 8.50211 8.95714 6.45695 6.86321 8.56032 7.77198 7.68621 6.38574 5.67858 4.21565 3.98223
+threshold=15.225000000000001 -0.29166666666667135 0.56584311806914556 -6.9999999999999973 0.46489792570397087 16.515151515151516 123.68750000000001 227.82000000000002 -0.75595238095237949 0.025274304665849606 -1.705357142857143 -1.0000000180025095e-35 0.50860236372279055 222.78125000000003
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 5 3 -3 -5 6 7 9 -9 -1 -6 -2 -13 -4
+right_child=11 2 13 4 10 -7 -8 8 -10 -11 -12 12 -14 -15
+leaf_value=0.0087138894445027461 -0.01248475536504879 -0.052100240369848241 0.040799272900499305 0.024363685744045852 -0.051816351953662361 0.042735686521304467 0.040009035522266888 -0.046006108176515285 0.00273483800408156 -0.021635092287458264 -0.0115203606180113 0.0090547062831142257 0.050240538556617337 -0.0035196794361016148
+leaf_weight=76.604642063379288 6.6097762733697918 8.6576687693595868 6.0909906178712827 10.348592042922972 6.9732603579759589 6.0767100751399985 6.6403718292713156 11.978713899850847 9.2968079298734647 16.170377686619759 64.432133376598358 7.2736790329217937 8.7717214673757535 6.9399073719978333
+leaf_count=313 27 37 26 43 29 25 27 49 38 66 264 30 36 29
+internal_value=-0.00133294 -0.00330607 -0.0104257 -0.0144068 -0.0104152 0.0025036 0.000477939 -0.00182368 -0.0247077 0.00342416 -0.0154556 0.0187169 0.0315702 0.0171962
+internal_weight=252.865 230.21 103.443 90.4117 81.754 126.768 120.691 114.051 21.2755 92.775 71.4054 22.6552 16.0454 13.0309
+internal_count=1039 946 428 373 336 518 493 466 87 379 293 93 66 55
+is_linear=0
+shrinkage=0.04
+
+
+Tree=25
+num_leaves=15
+num_cat=0
+split_feature=33 87 85 10 83 10 39 86 72 49 13 16 38 27
+split_gain=7.25855 6.38507 8.41516 9.2502 8.14048 7.48236 8.40852 7.85339 11.0386 8.60242 6.83818 5.86449 5.49791 3.04698
+threshold=5.4583333333333348 1.5850000000000002 1.0000000180025095e-35 117.22500000000001 0.54234668644906048 116.93750000000001 -1.0000000180025095e-35 1.5650000000000002 162.69282608695656 0.75102962846491172 104.77500000000002 -8.9374999999999982 4.1833333333333345 0.020833333333333655
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 10 5 4 11 7 -7 9 -9 -3 -1 -4 -8 -6
+right_child=-2 2 3 -5 13 6 12 8 -10 -11 -12 -13 -14 -15
+leaf_value=-0.041539672781130549 -0.031422067002150791 0.042995214924070081 0.042296436297125074 -0.023883650662784965 0.072297264891014304 -0.009582647504040049 0.058812399794648744 0.021985462315431858 -0.014896003510037621 -0.0040262327529876152 0.0035283522947714635 0.0075685995167286092 0.011039775290075307 0.0323219849604569
+leaf_weight=10.137894913554193 10.139534831047056 10.71300193667412 9.8288029283285123 7.8387844264507285 5.8450987040996534 9.664890334010126 8.7909274846315366 15.362282529473303 83.881821304559708 14.860007524490355 11.493947580456732 37.329559937119484 6.8639661371707907 6.381435826420784
+leaf_count=42 43 45 40 32 24 40 36 63 345 62 47 153 28 26
+internal_value=0.00172561 0.00313194 0.0051945 0.0169566 0.0223475 -7.19483e-05 0.0197544 -0.00409382 -0.00918701 0.0156719 -0.0175931 0.0148066 0.0378663 0.0514328
+internal_weight=249.132 238.992 217.361 67.2237 59.3849 150.137 25.3198 124.817 99.2441 25.573 21.6318 47.1584 15.6549 12.2265
+internal_count=1026 983 894 275 243 619 104 515 408 107 89 193 64 50
+is_linear=0
+shrinkage=0.04
+
+
+Tree=26
+num_leaves=13
+num_cat=0
+split_feature=48 87 75 13 13 26 98 83 54 28 63 26
+split_gain=6.07316 5.62173 8.54781 6.21306 5.95377 6.62941 7.29602 6.07248 5.64674 6.51449 5.46195 3.27744
+threshold=0.064872666259492118 1.5850000000000002 0.69045454545454554 104.77500000000002 120.56250000000001 15.072916666666668 -11.562499999999998 0.49675474226372424 20.535714285714288 40.187500000000007 0.51085383914331295 6.072916666666667
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 3 4 -1 5 6 -3 -7 -4 11 -2 -10
+right_child=10 2 8 -5 -6 7 -8 -9 9 -11 -12 -13
+leaf_value=-0.039674658535771484 -0.052512934017087537 -0.014023176104202862 -0.005798976431383154 0.0036351517375994916 -0.026305412473366974 0.0062814492481233046 0.010148203473004854 -0.041049983242601396 0.028561765576098901 0.0087152875473318417 -0.0029143682076594587 0.066287713324515871
+leaf_weight=9.8422116041183489 6.0319006294012061 23.719328477978706 7.8761165887117377 11.48290069401264 11.350633054971693 7.9110089093446758 126.75102043151855 9.5997582674026471 6.5257693231105831 10.448119834065436 8.6423251926898939 8.462289631366728
+leaf_count=41 25 97 32 47 47 33 522 41 27 43 36 35
+internal_value=0.00166 0.00322559 0.00518911 -0.0163537 0.00173262 0.00362718 0.00633796 -0.0196666 0.0237966 0.0329606 -0.0233021 0.0498619
+internal_weight=248.643 233.969 212.644 21.3251 179.332 167.981 150.47 17.5108 33.3123 25.4362 14.6742 14.9881
+internal_count=1026 965 877 88 740 693 619 74 137 105 61 62
+is_linear=0
+shrinkage=0.04
+
+
+Tree=27
+num_leaves=15
+num_cat=0
+split_feature=33 40 43 64 56 29 74 7 16 12 36 53 32 33
+split_gain=6.67537 6.00723 6.58775 6.4086 6.22146 8.22654 7.17113 5.57557 10.8982 10.7588 6.64454 7.95563 6.24334 4.86842
+threshold=5.4583333333333348 10.937500000000002 0.53985767334155887 0.34495732674280544 30.562500000000004 32.791666666666679 0.62250000000000016 59.166666666666679 3.7916666666666647 9.1339285714285712 -0.34166666666666673 22.387500000000003 23.791666666666668 -0.29166666666666602
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 3 7 -1 -4 -6 -7 8 9 -3 12 -12 -9 -5
+right_child=-2 2 4 13 5 6 -8 10 -10 -11 11 -13 -14 -15
+leaf_value=-0.04539631182232725 -0.030331123415790143 0.0036500818553591068 -0.017115468469559102 -0.026046588004955247 0.065457960355147352 0.02547423439415672 -0.018488966847576102 0.017724882848208653 -0.041424367213409224 -0.047501812723565191 -0.0045522301063454888 0.04416916038732871 -0.038718688099103261 0.024752126334750945
+leaf_weight=8.1224037855863589 10.053963825106619 115.14034233987331 6.9894797801971427 5.7684260606765747 6.3827460259199134 27.928439050912857 7.5389710813760749 6.7571853250265104 10.671643391251562 6.9777127951383582 8.1633969545364398 15.628093481063841 5.8501180559396744 6.3321559280157071
+leaf_count=34 43 476 29 24 26 114 31 28 44 29 34 64 24 26
+internal_value=0.00159555 0.00294283 0.00487723 -0.0179123 0.0178183 0.0236527 0.0161294 0.00114151 -0.00266021 0.00072731 0.0150109 0.0274518 -0.00846641 0.000536049
+internal_weight=248.305 238.251 218.028 20.223 48.8396 41.8502 35.4674 169.188 132.79 122.118 36.3988 23.7915 12.6073 12.1006
+internal_count=1026 983 899 84 200 171 145 699 549 505 150 98 52 50
+is_linear=0
+shrinkage=0.04
+
+
+Tree=28
+num_leaves=13
+num_cat=0
+split_feature=33 27 14 48 24 53 59 57 34 47 81 50
+split_gain=6.19142 5.48502 8.27407 6.44704 5.11208 5.11786 5.55155 5.07182 5.97421 8.76085 8.56983 3.46147
+threshold=5.4583333333333348 -2.3020833333333326 85.312500000000014 0.064872666259492118 -1.0000000180025095e-35 21.291666666666668 23.387500000000003 45.687500000000007 6.8875000000000011 0.37218684558476361 1.7150000000000001 0.74075516458343793
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 2 11 7 -4 -6 -7 8 10 -10 -3 -1
+right_child=-2 3 4 -5 5 6 -8 -9 9 -11 -12 -13
+leaf_value=0.036467676081935275 -0.029325034647802492 0.012704755728250297 -0.051764929617036118 -0.023669451716433799 -0.044508533316403635 0.026446805663908529 -0.027271352696527536 -0.022833580306035422 0.022463638898768467 -0.0033374130186977686 -0.014458359978742813 -0.0028572785771652266
+leaf_weight=6.0484680682420722 9.9843682050704938 40.375474900007248 7.6424536705017116 11.367303296923636 5.5812820345163372 6.6618274450302106 5.7221347242593765 8.4949828088283521 73.357022643089294 29.534479916095734 34.431760281324387 8.7800204604864103
+leaf_count=25 43 166 32 47 24 28 24 35 302 121 143 36
+internal_value=0.0015332 0.00282775 -0.0105946 0.005575 -0.0243635 -0.0127068 0.00162579 0.0073604 0.00880384 0.0150576 0.000202303 0.0131832
+internal_weight=247.982 237.997 40.4362 197.561 25.6077 17.9652 12.384 186.194 177.699 102.892 74.8072 14.8285
+internal_count=1026 983 169 814 108 76 52 767 732 423 309 61
+is_linear=0
+shrinkage=0.04
+
+
+Tree=29
+num_leaves=17
+num_cat=0
+split_feature=87 85 10 83 41 73 86 39 8 44 13 76 61 36 97 45
+split_gain=5.37924 8.77104 7.1461 6.5763 6.24618 5.74552 7.24104 5.90731 7.82727 5.90939 5.68942 4.92086 12.7968 7.49136 4.69159 2.29423
+threshold=1.5850000000000002 1.0000000180025095e-35 117.22500000000001 0.54234668644906048 10.812500000000002 0.53158244680851074 1.7450000000000003 -0.61249999999999993 47.727272727272734 0.48331411181158185 104.77500000000002 2.4650000000000003 12.866071428571431 0.28869047619047633 1.4062500000000002 -0.013905145374354397
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=10 4 3 11 -2 6 -6 8 -7 -9 -1 13 -13 -3 -12 -5
+right_child=1 2 -4 15 5 7 -8 9 -10 -11 14 12 -14 -15 -16 -17
+leaf_value=-0.039294680659493833 -0.031671221811972641 0.037455766277146953 -0.018600965920339822 0.063774142191859146 0.050889907105456336 -0.036046187526128669 -0.0011468294092016626 -0.016947588402893 -0.00031638211057623142 0.0084049263294318916 0.026762860869410491 0.035225255717854904 -0.041754796373233906 -0.00065805839704901963 -0.023845024484234915 0.029272484285479398
+leaf_weight=10.1972071826458 10.532053381204603 19.837578102946281 8.7409028112888318 6.0329279154539108 7.6620817482471493 16.978984668850899 9.6890967190265638 18.620566442608833 23.233949556946754 70.049215823411942 5.8855016827583295 6.3545227348804456 7.5724885612726212 14.127186641097067 5.8383642733097076 6.3081436455249769
+leaf_count=43 44 82 36 25 32 71 40 78 96 290 24 26 31 58 24 26
+internal_value=0.0014732 0.00331024 0.0151971 0.0201018 -0.00191971 0.000223048 0.021832 -0.00268611 -0.0154025 0.00308092 -0.0174444 0.0133924 -0.00663086 0.0216028 0.00156066 0.0461386
+internal_weight=247.661 225.74 68.9738 60.2328 156.766 146.234 17.3512 128.883 40.2129 88.6698 21.9211 47.8918 13.927 33.9648 11.7239 12.3411
+internal_count=1026 935 284 248 651 607 72 535 167 368 91 197 57 140 48 51
+is_linear=0
+shrinkage=0.04
+
+
+end of trees
+
+feature_importances:
+Column_33=16
+Column_55=14
+Column_75=13
+Column_95=13
+Column_17=12
+Column_27=12
+Column_40=12
+Column_60=12
+Column_88=12
+Column_87=11
+Column_11=10
+Column_97=10
+Column_14=9
+Column_36=9
+Column_53=9
+Column_64=9
+Column_86=9
+Column_31=8
+Column_54=8
+Column_73=8
+Column_15=7
+Column_26=7
+Column_29=7
+Column_39=7
+Column_62=7
+Column_63=7
+Column_9=6
+Column_10=6
+Column_12=6
+Column_18=6
+Column_28=6
+Column_51=6
+Column_61=6
+Column_77=6
+Column_13=5
+Column_24=5
+Column_35=5
+Column_38=5
+Column_46=5
+Column_48=5
+Column_58=5
+Column_65=5
+Column_74=5
+Column_80=5
+Column_8=4
+Column_30=4
+Column_32=4
+Column_41=4
+Column_43=4
+Column_45=4
+Column_49=4
+Column_72=4
+Column_82=4
+Column_83=4
+Column_16=3
+Column_25=3
+Column_34=3
+Column_47=3
+Column_50=3
+Column_52=3
+Column_56=3
+Column_59=3
+Column_79=3
+Column_81=3
+Column_85=3
+Column_89=3
+Column_90=3
+Column_98=3
+Column_37=2
+Column_42=2
+Column_57=2
+Column_69=2
+Column_76=2
+Column_96=2
+Column_7=1
+Column_21=1
+Column_44=1
+Column_66=1
+Column_68=1
+Column_71=1
+
+parameters:
+[boosting: gbdt]
+[objective: binary]
+[metric: binary_logloss]
+[tree_learner: serial]
+[device_type: cpu]
+[data_sample_strategy: bagging]
+[data: ]
+[valid: ]
+[num_iterations: 1200]
+[learning_rate: 0.04]
+[num_leaves: 31]
+[num_threads: 4]
+[seed: 42]
+[deterministic: 0]
+[force_col_wise: 0]
+[force_row_wise: 0]
+[histogram_pool_size: -1]
+[max_depth: 6]
+[min_data_in_leaf: 24]
+[min_sum_hessian_in_leaf: 0.001]
+[bagging_fraction: 0.84]
+[pos_bagging_fraction: 1]
+[neg_bagging_fraction: 1]
+[bagging_freq: 5]
+[bagging_seed: 400]
+[bagging_by_query: 0]
+[feature_fraction: 0.82]
+[feature_fraction_bynode: 1]
+[feature_fraction_seed: 30056]
+[extra_trees: 0]
+[extra_seed: 12879]
+[early_stopping_round: 0]
+[early_stopping_min_delta: 0]
+[first_metric_only: 0]
+[max_delta_step: 0]
+[lambda_l1: 0]
+[lambda_l2: 0]
+[linear_lambda: 0]
+[min_gain_to_split: 0]
+[drop_rate: 0.1]
+[max_drop: 50]
+[skip_drop: 0.5]
+[xgboost_dart_mode: 0]
+[uniform_drop: 0]
+[drop_seed: 17869]
+[top_rate: 0.2]
+[other_rate: 0.1]
+[min_data_per_group: 100]
+[max_cat_threshold: 32]
+[cat_l2: 10]
+[cat_smooth: 10]
+[max_cat_to_onehot: 4]
+[top_k: 20]
+[monotone_constraints: ]
+[monotone_constraints_method: basic]
+[monotone_penalty: 0]
+[feature_contri: ]
+[forcedsplits_filename: ]
+[refit_decay_rate: 0.9]
+[cegb_tradeoff: 1]
+[cegb_penalty_split: 0]
+[cegb_penalty_feature_lazy: ]
+[cegb_penalty_feature_coupled: ]
+[path_smooth: 0]
+[interaction_constraints: ]
+[verbosity: -1]
+[saved_feature_importance_type: 0]
+[use_quantized_grad: 0]
+[num_grad_quant_bins: 4]
+[quant_train_renew_leaf: 0]
+[stochastic_rounding: 1]
+[linear_tree: 0]
+[max_bin: 255]
+[max_bin_by_feature: ]
+[min_data_in_bin: 3]
+[bin_construct_sample_cnt: 200000]
+[data_random_seed: 175]
+[is_enable_sparse: 1]
+[enable_bundle: 1]
+[use_missing: 1]
+[zero_as_missing: 0]
+[feature_pre_filter: 1]
+[pre_partition: 0]
+[two_round: 0]
+[header: 0]
+[label_column: ]
+[weight_column: ]
+[group_column: ]
+[ignore_column: ]
+[categorical_feature: ]
+[forcedbins_filename: ]
+[precise_float_parser: 0]
+[parser_config_file: ]
+[objective_seed: 16083]
+[num_class: 1]
+[is_unbalance: 0]
+[scale_pos_weight: 1]
+[sigmoid: 1]
+[boost_from_average: 1]
+[reg_sqrt: 0]
+[alpha: 0.9]
+[fair_c: 1]
+[poisson_max_delta_step: 0.7]
+[tweedie_variance_power: 1.5]
+[lambdarank_truncation_level: 30]
+[lambdarank_norm: 1]
+[label_gain: ]
+[lambdarank_position_bias_regularization: 0]
+[eval_at: ]
+[multi_error_top_k: 1]
+[auc_mu_weights: ]
+[num_machines: 1]
+[local_listen_port: 12400]
+[time_out: 120]
+[machine_list_filename: ]
+[machines: ]
+[gpu_platform_id: -1]
+[gpu_device_id: -1]
+[gpu_use_dp: 0]
+[num_gpu: 1]
+
+end of parameters
+
+pandas_categorical:null
@@ -0,0 +1,202 @@
+tree
+version=v4
+num_class=1
+num_tree_per_iteration=1
+label_index=0
+max_feature_idx=98
+objective=binary sigmoid:1
+feature_names=Column_0 Column_1 Column_2 Column_3 Column_4 Column_5 Column_6 Column_7 Column_8 Column_9 Column_10 Column_11 Column_12 Column_13 Column_14 Column_15 Column_16 Column_17 Column_18 Column_19 Column_20 Column_21 Column_22 Column_23 Column_24 Column_25 Column_26 Column_27 Column_28 Column_29 Column_30 Column_31 Column_32 Column_33 Column_34 Column_35 Column_36 Column_37 Column_38 Column_39 Column_40 Column_41 Column_42 Column_43 Column_44 Column_45 Column_46 Column_47 Column_48 Column_49 Column_50 Column_51 Column_52 Column_53 Column_54 Column_55 Column_56 Column_57 Column_58 Column_59 Column_60 Column_61 Column_62 Column_63 Column_64 Column_65 Column_66 Column_67 Column_68 Column_69 Column_70 Column_71 Column_72 Column_73 Column_74 Column_75 Column_76 Column_77 Column_78 Column_79 Column_80 Column_81 Column_82 Column_83 Column_84 Column_85 Column_86 Column_87 Column_88 Column_89 Column_90 Column_91 Column_92 Column_93 Column_94 Column_95 Column_96 Column_97 Column_98
+feature_infos=none none none none none none none [0:100] [0:100] [-100:100] [54:128.875] [61:138] [-41.333333333333329:24] [61:130.125] [59:133] [-50:34.916666666666671] [-28.666666666666657:32.5] [-24.5:27] [-35.5:31.833333333333329] [0:1] [0:1] [-1:1] [0:12] [0:12] [-12:10] [0.91666666666666663:186.1875] [0.85416666666666663:185.08333333333337] [-179.02083333333334:184.16666666666663] [20:54] [22:56] [-21:15.833333333333332] [11:34.5] [9:36] [-15:13.333333333333332] [2:13] [3:13] [-8:5.5] [0.875:9] [0:12] [-9:4.875] [7:22] [8:23] [-10:10] [0.41025641025641019:0.67647058823529416] [0.39730639730639727:0.76744186046511631] [-0.3174418604651163:0.22647058823529409] [0.20419254658385089:0.4825000000000001] [0.1875:0.54166666666666663] [-0.22171945701357459:0.17923280423280419] [0.47826086956521741:0.87898457080200498] [0.42857142857142849:0.88636363636363635] [-0.29647435897435898:0.38962801311591622] [11:39.666666666666664] [15.5:40] [10:31.875] [11.5:34] [15:56] [17:57] [12:32.125] [10:38] [8:20] [7:22] [0.40000000000000002:0.69047619047619047] [0.3902439024390244:0.71739130434782605] [0.23753976670201479:0.51851851851851849] [0.1707317073170731:0.54545454545454541] [0:8] [0:1] [120:295] [-38:36] [0:1] [0:1] [140.39130434782609:233.09999999999999] [0:1] [0:1] [0:1] [1.05:4.1100000000000003] [1.05:4.1299999999999999] [0.2034883720930232:0.79729729729729726] [0.20270270270270269:0.79651162790697683] [145.5:257.5] [1.3:7.7599999999999998] [1.4099999999999999:7.5599999999999996] [0.1789976133651551:0.75977653631284914] [0.24022346368715081:0.82100238663484482] [-15.5:12.5] [1.3:2.7200000000000002] [1.1799999999999999:2.7799999999999998] [0.36298076923076922:0.64953271028037374] [0.35046728971962621:0.63701923076923073] [0.1918833727344364:0.21555133935749429] none none none none [132:250.6875] [126.25:256.625] [-63.5:88.6875] [-35.5:27.5]
+tree_sizes=1714 1917
+
+Tree=0
+num_leaves=15
+num_cat=0
+split_feature=72 82 49 25 36 25 17 77 34 69 25 40 80 40
+split_gain=11.2305 10.9895 14.5557 11.7291 11.5678 6.991 6.42947 6.52716 10.0318 9.34909 5.86638 5.89396 5.34606 8.20903
+threshold=232.51500000000001 1.8250000000000004 0.74446554478882077 2.8645833333333335 -0.46874999999999994 1.0104166666666667 12.562500000000002 2.6750000000000003 5.6339285714285721 -5.4166666666666652 3.1145833333333335 12.803571428571431 162.00000000000003 13.937500000000002
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=1 5 10 4 -4 -1 7 8 -7 -9 -3 -12 -5 -14
+right_child=-2 2 3 12 -6 6 -8 9 -10 -11 11 -13 13 -15
+leaf_value=-0.014742735215146609 -0.095823069621212592 -0.030752227995962191 -0.086785452728816673 0.017792685597478597 -0.021483574280753166 -0.0010203128315903962 -0.085759203191584921 -0.020079232808751797 -0.05043362279072628 -0.074223259488395713 -0.046761720776777753 -0.098557138597063443 -0.031433483007911781 0.014451045738105336
+leaf_weight=7.4955528974533072 7.7454046607017508 6.2462940812110928 7.995256423950198 7.7454046607017508 9.4943670034408552 6.99584937095642 9.7442187666892988 5.9964423179626456 108.93536877632141 34.229691565036774 5.9964423179626456 8.4949599504470807 23.486065745353702 8.4949599504470807
+leaf_count=30 31 25 32 31 38 28 39 24 436 137 24 34 94 34
+internal_value=-0.0483827 -0.0469209 -0.0344467 -0.0240408 -0.0513359 -0.0525288 -0.054236 -0.052269 -0.0474518 -0.0661521 -0.063157 -0.0771246 -0.0120241 -0.0192454
+internal_weight=259.096 251.351 77.9538 57.2161 17.4896 173.397 165.902 156.157 115.931 40.2261 20.7377 14.4914 39.7264 31.981
+internal_count=1037 1006 312 229 70 694 664 625 464 161 83 58 159 128
+is_linear=0
+shrinkage=1
+
+
+Tree=1
+num_leaves=17
+num_cat=0
+split_feature=52 63 82 49 63 11 9 22 47 27 26 50 60 68 37 64
+split_gain=9.46149 12.0286 10.1725 11.5657 11.422 11.4943 11.2254 9.35335 10.3758 7.46163 7.15253 10.8161 5.87382 5.6308 5.10807 3.94362
+threshold=18.267857142857146 0.57978414386394084 1.7650000000000003 0.74446554478882077 0.52121781606433182 81.062500000000014 8.7121212121212164 1.5000000000000002 0.36820747200853426 0.06249999999999991 7.0312500000000009 0.79401716042796011 12.35416666666667 161.75000000000003 4.5500000000000007 0.34986080718052731
+decision_type=2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
+left_child=15 2 4 9 5 -2 -7 8 -6 13 11 -5 -12 -4 -9 -1
+right_child=1 -3 3 10 7 6 -8 14 -10 -11 12 -13 -14 -15 -16 -17
+leaf_value=-0.057339030773059012 0.028542958096860364 -0.044782355190073488 0.032618410031766333 0.0057409124284739923 0.013389736272609485 -0.026136292703093016 0.010233031617588078 0.056167817502913067 -0.029699787865729181 -0.038327130963158276 0.074132616447759023 0.052492105838845886 0.026735863001827433 -0.01725653802460729 0.0087599672849197358 -0.011453089463718463
+leaf_weight=5.9920798838138563 9.7432544529438001 8.4919032305479032 7.2431264519691485 42.224371567368507 31.477784723043442 57.952298685908318 17.733558729290962 9.2429284304380399 12.488689020276068 9.2367470711469633 6.4985252916812923 9.7452246546745283 11.743822261691092 7.2440863251686096 5.9950847774744025 5.9950532913208008
+leaf_count=24 39 34 29 169 126 232 71 37 50 37 26 39 47 29 24 24
+internal_value=0.000314777 0.00199863 0.0036638 0.0139129 -0.00299273 -0.0123505 -0.0176148 0.01051 0.00115015 -0.010233 0.0220716 0.0145076 0.0436201 0.00767928 0.0375162 -0.0343904
+internal_weight=259.049 247.061 238.57 93.9359 144.634 85.4291 75.6859 59.2045 43.9665 23.724 70.2119 51.9696 18.2423 14.4872 15.238 11.9871
+internal_count=1037 989 955 376 579 342 303 237 176 95 281 208 73 58 61 48
+is_linear=0
+shrinkage=0.04
+
+
+end of trees
+
+feature_importances:
+Column_25=3
+Column_40=2
+Column_49=2
+Column_63=2
+Column_82=2
+Column_9=1
+Column_11=1
+Column_17=1
+Column_22=1
+Column_26=1
+Column_27=1
+Column_34=1
+Column_36=1
+Column_37=1
+Column_47=1
+Column_50=1
+Column_52=1
+Column_60=1
+Column_64=1
+Column_68=1
+Column_69=1
+Column_72=1
+Column_77=1
+Column_80=1
+
+parameters:
+[boosting: gbdt]
+[objective: binary]
+[metric: binary_logloss]
+[tree_learner: serial]
+[device_type: cpu]
+[data_sample_strategy: bagging]
+[data: ]
+[valid: ]
+[num_iterations: 1200]
+[learning_rate: 0.04]
+[num_leaves: 31]
+[num_threads: 4]
+[seed: 42]
+[deterministic: 0]
+[force_col_wise: 0]
+[force_row_wise: 0]
+[histogram_pool_size: -1]
+[max_depth: 6]
+[min_data_in_leaf: 24]
+[min_sum_hessian_in_leaf: 0.001]
+[bagging_fraction: 0.84]
+[pos_bagging_fraction: 1]
+[neg_bagging_fraction: 1]
+[bagging_freq: 5]
+[bagging_seed: 400]
+[bagging_by_query: 0]
+[feature_fraction: 0.82]
+[feature_fraction_bynode: 1]
+[feature_fraction_seed: 30056]
+[extra_trees: 0]
+[extra_seed: 12879]
+[early_stopping_round: 0]
+[early_stopping_min_delta: 0]
+[first_metric_only: 0]
+[max_delta_step: 0]
+[lambda_l1: 0]
+[lambda_l2: 0]
+[linear_lambda: 0]
+[min_gain_to_split: 0]
+[drop_rate: 0.1]
+[max_drop: 50]
+[skip_drop: 0.5]
+[xgboost_dart_mode: 0]
+[uniform_drop: 0]
+[drop_seed: 17869]
+[top_rate: 0.2]
+[other_rate: 0.1]
+[min_data_per_group: 100]
+[max_cat_threshold: 32]
+[cat_l2: 10]
+[cat_smooth: 10]
+[max_cat_to_onehot: 4]
+[top_k: 20]
+[monotone_constraints: ]
+[monotone_constraints_method: basic]
+[monotone_penalty: 0]
+[feature_contri: ]
+[forcedsplits_filename: ]
+[refit_decay_rate: 0.9]
+[cegb_tradeoff: 1]
+[cegb_penalty_split: 0]
+[cegb_penalty_feature_lazy: ]
+[cegb_penalty_feature_coupled: ]
+[path_smooth: 0]
+[interaction_constraints: ]
+[verbosity: -1]
+[saved_feature_importance_type: 0]
+[use_quantized_grad: 0]
+[num_grad_quant_bins: 4]
+[quant_train_renew_leaf: 0]
+[stochastic_rounding: 1]
+[linear_tree: 0]
+[max_bin: 255]
+[max_bin_by_feature: ]
+[min_data_in_bin: 3]
+[bin_construct_sample_cnt: 200000]
+[data_random_seed: 175]
+[is_enable_sparse: 1]
+[enable_bundle: 1]
+[use_missing: 1]
+[zero_as_missing: 0]
+[feature_pre_filter: 1]
+[pre_partition: 0]
+[two_round: 0]
+[header: 0]
+[label_column: ]
+[weight_column: ]
+[group_column: ]
+[ignore_column: ]
+[categorical_feature: ]
+[forcedbins_filename: ]
+[precise_float_parser: 0]
+[parser_config_file: ]
+[objective_seed: 16083]
+[num_class: 1]
+[is_unbalance: 0]
+[scale_pos_weight: 1]
+[sigmoid: 1]
+[boost_from_average: 1]
+[reg_sqrt: 0]
+[alpha: 0.9]
+[fair_c: 1]
+[poisson_max_delta_step: 0.7]
+[tweedie_variance_power: 1.5]
+[lambdarank_truncation_level: 30]
+[lambdarank_norm: 1]
+[label_gain: ]
+[lambdarank_position_bias_regularization: 0]
+[eval_at: ]
+[multi_error_top_k: 1]
+[auc_mu_weights: ]
+[num_machines: 1]
+[local_listen_port: 12400]
+[time_out: 120]
+[machine_list_filename: ]
+[machines: ]
+[gpu_platform_id: -1]
+[gpu_device_id: -1]
+[gpu_use_dp: 0]
+[num_gpu: 1]
+
+end of parameters
+
+pandas_categorical:null
@@ -0,0 +1,467 @@
+"""
+Calibration Module for XGBoost Models
+=====================================
+Calibrates raw probabilities from XGBoost models using Isotonic Regression.
+Ensures that a predicted probability of 70% actually corresponds to a 70% win rate.
+
+Usage:
+    from ai_engine.models.calibration import Calibrator
+    calibrator = Calibrator()
+    calibrated_prob = calibrator.calibrate("ms", raw_prob)
+    
+    # Training new calibration models:
+    calibrator.train_calibration(valid_df, market="ms")
+"""
+
+import os
+import pickle
+import json
+import numpy as np
+import pandas as pd
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple, Any
+from sklearn.isotonic import IsotonicRegression
+from sklearn.calibration import calibration_curve
+from sklearn.metrics import brier_score_loss
+
+AI_ENGINE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CALIBRATION_DIR = os.path.join(AI_ENGINE_DIR, "models", "calibration")
+
+os.makedirs(CALIBRATION_DIR, exist_ok=True)
+
+# Supported markets for calibration
+SUPPORTED_MARKETS = [
+    "ms",        # Match Result (1X2) - multi-class, calibrated per class
+    "ms_home",   # Standard Home win probability
+    "ms_home_heavy_fav", # Context: home odds <= 1.40
+    "ms_home_fav",       # Context: 1.40 < home odds <= 1.80
+    "ms_home_balanced",  # Context: 1.80 < home odds <= 2.50
+    "ms_home_underdog",  # Context: home odds > 2.50
+    "ms_draw",   # Draw probability  
+    "ms_away",   # Away win probability
+    "ou15",      # Over/Under 1.5
+    "ou25",      # Over/Under 2.5
+    "ou35",      # Over/Under 3.5
+    "btts",      # Both Teams to Score
+    "ht_ft",     # Half-Time/Full-Time
+    "dc",        # Double Chance
+    "ht",        # Half-Time Result
+    "ht_home",   # Half-Time Home win
+    "ht_draw",   # Half-Time Draw
+    "ht_away",   # Half-Time Away win
+]
+
+
+class CalibrationMetrics:
+    """Stores calibration quality metrics for a market."""
+    
+    def __init__(self):
+        self.brier_score: float = 0.0
+        self.calibration_error: float = 0.0
+        self.sample_count: int = 0
+        self.last_trained: str = ""
+        self.mean_predicted: float = 0.0
+        self.mean_actual: float = 0.0
+        
+    def to_dict(self) -> Dict:
+        return {
+            "brier_score": round(self.brier_score, 4),
+            "calibration_error": round(self.calibration_error, 4),
+            "sample_count": self.sample_count,
+            "last_trained": self.last_trained,
+            "mean_predicted": round(self.mean_predicted, 4),
+            "mean_actual": round(self.mean_actual, 4),
+        }
+
+
+class Calibrator:
+    """
+    Probability calibration using Isotonic Regression.
+    
+    Isotonic Regression is a non-parametric method that fits a piecewise
+    constant function that is monotonically increasing. It's ideal for
+    calibrating probabilities because:
+    
+    1. It preserves ranking (if P(A) > P(B) before, P(A) > P(B) after)
+    2. It doesn't assume a specific distribution shape
+    3. It can correct systematic over/under-confidence
+    
+    Example:
+        # Before calibration: model predicts 70% but actual win rate is 60%
+        # After calibration: model predicts 70% → calibrated to 60%
+    """
+    
+    def __init__(self):
+        self.calibrators: Dict[str, IsotonicRegression] = {}
+        self.metrics: Dict[str, CalibrationMetrics] = {}
+        # Less aggressive shrinkage — only meaningful overconfident bands are pulled.
+        # Default raised from ~0.85-0.90 to 0.95+ since the orchestrator and config
+        # already apply market-level multipliers; double-shrinkage was the root cause
+        # of 24-35pt avg calibrated-vs-raw drops in production traces.
+        self.heuristic_fallback: Dict[str, float] = {
+            "ms": 0.96,
+            "ms_home": 0.96,
+            "ms_home_heavy_fav": 0.98,
+            "ms_home_fav": 0.96,
+            "ms_home_balanced": 0.94,
+            "ms_home_underdog": 0.92,
+            "ms_draw": 0.94,
+            "ms_away": 0.96,
+            "ou15": 0.96,
+            "ou25": 0.96,
+            "ou35": 0.94,
+            "btts": 0.96,
+            "ht_ft": 0.92,
+            "dc": 0.97,
+            "ht": 0.92,
+            "ht_home": 0.92,
+            "ht_draw": 0.92,
+            "ht_away": 0.92,
+        }
+        self._load_calibrators()
+        
+    def _load_calibrators(self):
+        """Load trained calibrators for each market from disk."""
+        for market in SUPPORTED_MARKETS:
+            model_path = os.path.join(CALIBRATION_DIR, f"{market}_calibrator.pkl")
+            metrics_path = os.path.join(CALIBRATION_DIR, f"{market}_metrics.json")
+            
+            if os.path.exists(model_path):
+                try:
+                    with open(model_path, "rb") as f:
+                        self.calibrators[market] = pickle.load(f)
+                    print(f"[Calibrator] Loaded calibration model for {market}")
+                except Exception as e:
+                    print(f"[Calibrator] Warning: Failed to load {market}: {e}")
+                    
+            if os.path.exists(metrics_path):
+                try:
+                    with open(metrics_path, "r") as f:
+                        data = json.load(f)
+                        metrics = CalibrationMetrics()
+                        metrics.brier_score = data.get("brier_score", 0.0)
+                        metrics.calibration_error = data.get("calibration_error", 0.0)
+                        metrics.sample_count = data.get("sample_count", 0)
+                        metrics.last_trained = data.get("last_trained", "")
+                        metrics.mean_predicted = data.get("mean_predicted", 0.0)
+                        metrics.mean_actual = data.get("mean_actual", 0.0)
+                        self.metrics[market] = metrics
+                except Exception as e:
+                    print(f"[Calibrator] Warning: Failed to load metrics for {market}: {e}")
+
+    # Below this sample count, the isotonic model is treated as untrained
+    # (raw_prob is returned). Between MIN and FLOOR we ramp from 0 to ~15%
+    # trust. Between FLOOR and CEILING we ramp to full trust.
+    # Rationale: 12-sample calibrators are statistical noise; even 30%
+    # blending on them propagates the noise into the confidence value the
+    # betting_brain reads downstream.
+    HARD_MIN_SAMPLES = 50
+    TRUSTED_SAMPLE_FLOOR = 100
+    TRUSTED_SAMPLE_CEILING = 400
+    # Hard cap on how far calibration can move probability in either direction.
+    MAX_DELTA = 0.20
+
+    def calibrate(self, market_type: str, raw_prob: float, odds_val: Optional[float] = None) -> float:
+        """
+        Calibrate a raw probability using Isotonic Regression with safeguards.
+
+        Args:
+            market_type (str): 'ms_home', 'ou25', 'btts', 'ht_ft', etc.
+            raw_prob (float): The raw probability from XGBoost (0.0 - 1.0)
+            odds_val (float, optional): The pre-match odds, used for context-aware bucket mapping
+
+        Returns:
+            float: Calibrated probability (0.0 - 1.0)
+
+        Safeguards:
+          * Low-sample trained models are blended with raw_prob to dampen overfit.
+          * MAX_DELTA caps the per-call adjustment (prevents 40pp swings).
+        """
+        # Normalize market type
+        market_key = market_type.lower().replace("-", "_")
+
+        # Route to bucket if ms_home and odds provided
+        if market_key == "ms_home" and odds_val is not None and odds_val > 1.0:
+            if odds_val <= 1.40:
+                bucket_key = "ms_home_heavy_fav"
+            elif odds_val <= 1.80:
+                bucket_key = "ms_home_fav"
+            elif odds_val <= 2.50:
+                bucket_key = "ms_home_balanced"
+            else:
+                bucket_key = "ms_home_underdog"
+
+            if bucket_key in self.calibrators:
+                market_key = bucket_key
+
+        # If we have a trained Isotonic Regression model, use it (with safeguards)
+        if market_key in self.calibrators:
+            try:
+                iso_pred = float(self.calibrators[market_key].predict([raw_prob])[0])
+
+                # Sample-count weighted blend with raw probability.
+                # Sparse models barely move probability; mature models dominate.
+                metrics = self.metrics.get(market_key)
+                n_samples = metrics.sample_count if metrics else 0
+                if n_samples < self.HARD_MIN_SAMPLES:
+                    # Below 50 samples isotonic fit is unreliable — bypass it
+                    # entirely and return raw_prob. The heuristic shrinkage
+                    # below would still apply a model-version multiplier elsewhere.
+                    return float(np.clip(raw_prob, 0.01, 0.99))
+                if n_samples >= self.TRUSTED_SAMPLE_CEILING:
+                    iso_weight = 1.0
+                elif n_samples <= self.TRUSTED_SAMPLE_FLOOR:
+                    # Linear ramp from 0% at HARD_MIN_SAMPLES to ~25% at FLOOR
+                    span = self.TRUSTED_SAMPLE_FLOOR - self.HARD_MIN_SAMPLES
+                    iso_weight = 0.25 * (n_samples - self.HARD_MIN_SAMPLES) / span
+                else:
+                    # Linearly ramp 25% → 100% between floor and ceiling
+                    span = self.TRUSTED_SAMPLE_CEILING - self.TRUSTED_SAMPLE_FLOOR
+                    iso_weight = 0.25 + 0.75 * (n_samples - self.TRUSTED_SAMPLE_FLOOR) / span
+                blended = iso_weight * iso_pred + (1.0 - iso_weight) * raw_prob
+
+                # Cap delta to avoid huge swings on noisy calibrators
+                delta = blended - raw_prob
+                if delta > self.MAX_DELTA:
+                    blended = raw_prob + self.MAX_DELTA
+                elif delta < -self.MAX_DELTA:
+                    blended = raw_prob - self.MAX_DELTA
+
+                return float(np.clip(blended, 0.01, 0.99))
+            except Exception as e:
+                print(f"[Calibrator] Warning: Isotonic failed for {market_key}: {e}")
+                # Fall through to heuristic
+
+        # Fallback to heuristic calibration
+        return self._heuristic_calibrate(market_key, raw_prob)
+    
+    def _heuristic_calibrate(self, market_type: str, raw_prob: float) -> float:
+        """
+        Heuristic calibration fallback when no trained model exists.
+        
+        This applies a conservative shrinkage towards the mean:
+        - Binary markets (OU, BTTS): shrink towards 0.5
+        - Multi-class (MS): shrink towards 0.33
+        - HT/FT: stronger shrinkage due to higher variance
+        """
+        # Get shrinkage factor for this market
+        shrinkage = self.heuristic_fallback.get(market_type, 0.90)
+        
+        if market_type in ["ms", "ms_home", "ms_home_heavy_fav", "ms_home_fav", "ms_home_balanced", "ms_home_underdog", "ms_draw", "ms_away"]:
+            # Pull towards 0.33 (uniform for 3-class)
+            return (raw_prob * shrinkage) + (0.33 * (1.0 - shrinkage))
+            
+        elif market_type in ["ou15", "ou25", "ou35", "btts"]:
+            # Pull towards 0.5 (uniform for binary)
+            return (raw_prob * shrinkage) + (0.5 * (1.0 - shrinkage))
+            
+        elif market_type in ["ht_ft", "ht"]:
+            # Stronger shrinkage for high-variance markets
+            return raw_prob * shrinkage
+            
+        elif market_type == "dc":
+            # Double chance is more reliable
+            return (raw_prob * shrinkage) + (0.66 * (1.0 - shrinkage))
+            
+        return raw_prob
+
+    def train_calibration(
+        self,
+        df: pd.DataFrame,
+        market: str,
+        prob_col: str,
+        actual_col: str,
+        min_samples: int = 100,
+        save: bool = True,
+    ) -> CalibrationMetrics:
+        """
+        Train an Isotonic Regression calibration model for a specific market.
+        
+        Args:
+            df: DataFrame with predictions and actual outcomes
+            market: Market identifier (e.g., 'ms_home', 'ou25', 'btts')
+            prob_col: Column name for raw probabilities
+            actual_col: Column name for actual outcomes (0 or 1)
+            min_samples: Minimum samples required to train
+            save: Whether to save the model to disk
+            
+        Returns:
+            CalibrationMetrics with quality metrics
+        """
+        # Filter valid data
+        valid_df = df[[prob_col, actual_col]].dropna()
+        n_samples = len(valid_df)
+        
+        if n_samples < min_samples:
+            print(f"[Calibrator] Warning: Only {n_samples} samples for {market}, "
+                  f"need at least {min_samples}")
+            metrics = CalibrationMetrics()
+            metrics.sample_count = n_samples
+            return metrics
+        
+        # Extract arrays
+        raw_probs = valid_df[prob_col].values
+        actuals = valid_df[actual_col].values
+        
+        # Train Isotonic Regression
+        iso = IsotonicRegression(out_of_bounds="clip", increasing=True)
+        iso.fit(raw_probs, actuals)
+        
+        # Calculate calibrated probabilities
+        calibrated_probs = iso.predict(raw_probs)
+        
+        # Calculate metrics
+        metrics = CalibrationMetrics()
+        metrics.sample_count = n_samples
+        metrics.last_trained = datetime.utcnow().isoformat()
+        metrics.brier_score = brier_score_loss(actuals, calibrated_probs)
+        metrics.mean_predicted = np.mean(raw_probs)
+        metrics.mean_actual = np.mean(actuals)
+        
+        # Calculate Expected Calibration Error (ECE)
+        metrics.calibration_error = self._calculate_ece(
+            calibrated_probs, actuals, n_bins=10
+        )
+        
+        # Store in memory
+        self.calibrators[market] = iso
+        self.metrics[market] = metrics
+        
+        # Save to disk
+        if save:
+            self._save_calibration(market, iso, metrics)
+        
+        print(f"[Calibrator] Trained {market}: "
+              f"Brier={metrics.brier_score:.4f}, "
+              f"ECE={metrics.calibration_error:.4f}, "
+              f"n={n_samples}")
+        
+        return metrics
+    
+    def train_all_markets(
+        self,
+        df: pd.DataFrame,
+        market_config: Dict[str, Tuple[str, str]],
+        min_samples: int = 100,
+    ) -> Dict[str, CalibrationMetrics]:
+        """
+        Train calibration models for multiple markets at once.
+        
+        Args:
+            df: DataFrame with all predictions and outcomes
+            market_config: Dict mapping market -> (prob_col, actual_col)
+                          e.g., {'ou25': ('ou25_over_prob', 'ou25_over_actual')}
+            min_samples: Minimum samples per market
+            
+        Returns:
+            Dict of market -> CalibrationMetrics
+        """
+        results = {}
+        
+        for market, (prob_col, actual_col) in market_config.items():
+            print(f"\n[Calibrator] Training {market}...")
+            try:
+                metrics = self.train_calibration(
+                    df=df,
+                    market=market,
+                    prob_col=prob_col,
+                    actual_col=actual_col,
+                    min_samples=min_samples,
+                    save=True,
+                )
+                results[market] = metrics
+            except Exception as e:
+                print(f"[Calibrator] Failed to train {market}: {e}")
+                
+        return results
+    
+    def _calculate_ece(
+        self, 
+        probs: np.ndarray, 
+        actuals: np.ndarray, 
+        n_bins: int = 10
+    ) -> float:
+        """
+        Calculate Expected Calibration Error (ECE).
+        
+        ECE = sum(|bin_accuracy - bin_confidence| * bin_weight)
+        
+        Lower is better. Perfect calibration = 0.
+        """
+        bin_boundaries = np.linspace(0, 1, n_bins + 1)
+        ece = 0.0
+        
+        for i in range(n_bins):
+            in_bin = (probs >= bin_boundaries[i]) & (probs < bin_boundaries[i + 1])
+            prop_in_bin = np.mean(in_bin)
+            
+            if prop_in_bin > 0:
+                accuracy_in_bin = np.mean(actuals[in_bin])
+                avg_confidence_in_bin = np.mean(probs[in_bin])
+                ece += np.abs(accuracy_in_bin - avg_confidence_in_bin) * prop_in_bin
+                
+        return ece
+    
+    def _save_calibration(
+        self, 
+        market: str, 
+        calibrator: IsotonicRegression,
+        metrics: CalibrationMetrics
+    ):
+        """Save calibration model and metrics to disk."""
+        # Save model
+        model_path = os.path.join(CALIBRATION_DIR, f"{market}_calibrator.pkl")
+        with open(model_path, "wb") as f:
+            pickle.dump(calibrator, f)
+            
+        # Save metrics
+        metrics_path = os.path.join(CALIBRATION_DIR, f"{market}_metrics.json")
+        with open(metrics_path, "w") as f:
+            json.dump(metrics.to_dict(), f, indent=2)
+            
+        print(f"[Calibrator] Saved {market} to {CALIBRATION_DIR}")
+    
+    def get_calibration_report(self) -> Dict[str, Any]:
+        """Generate a summary report of all calibration models."""
+        report = {
+            "trained_markets": list(self.calibrators.keys()),
+            "metrics": {},
+            "heuristic_only": [],
+        }
+        
+        for market in SUPPORTED_MARKETS:
+            if market in self.metrics:
+                report["metrics"][market] = self.metrics[market].to_dict()
+            elif market not in self.calibrators:
+                report["heuristic_only"].append(market)
+                
+        return report
+    
+    def get_calibrated_probabilities(
+        self, 
+        market: str, 
+        raw_probs: np.ndarray
+    ) -> np.ndarray:
+        """
+        Batch calibration for array of probabilities.
+        
+        Args:
+            market: Market type
+            raw_probs: Array of raw probabilities
+            
+        Returns:
+            Array of calibrated probabilities
+        """
+        return np.array([self.calibrate(market, p) for p in raw_probs])
+
+
+# Singleton instance
+_calibrator_instance: Optional[Calibrator] = None
+
+
+def get_calibrator() -> Calibrator:
+    """Get or create the global Calibrator instance."""
+    global _calibrator_instance
+    if _calibrator_instance is None:
+        _calibrator_instance = Calibrator()
+    return _calibrator_instance
@@ -0,0 +1,8 @@
+{
+  "brier_score": 0.1264,
+  "calibration_error": 0.0,
+  "sample_count": 26,
+  "last_trained": "2026-05-11T23:38:11.473645",
+  "mean_predicted": 0.757,
+  "mean_actual": 0.6923
+}
@@ -0,0 +1,8 @@
+{
+  "brier_score": 0.1667,
+  "calibration_error": 0.0,
+  "sample_count": 12,
+  "last_trained": "2026-05-11T23:38:11.484990",
+  "mean_predicted": 0.3579,
+  "mean_actual": 0.25
+}
@@ -0,0 +1,8 @@
+{
+  "brier_score": 0.196,
+  "calibration_error": 0.0,
+  "sample_count": 13,
+  "last_trained": "2026-05-11T23:38:11.500966",
+  "mean_predicted": 0.7239,
+  "mean_actual": 0.6154
+}
@@ -0,0 +1,8 @@
+{
+  "brier_score": 0.2222,
+  "calibration_error": 0.0,
+  "sample_count": 18,
+  "last_trained": "2026-05-11T23:38:11.508353",
+  "mean_predicted": 0.6258,
+  "mean_actual": 0.5
+}
@@ -0,0 +1,191 @@
+"""
+League-Specific Model Loader
+=============================
+Loads per-league XGBoost models + isotonic calibrators trained by
+scripts/train_league_models.py and provides a unified prediction interface.
+
+Falls back to general V25 for any market/league without a dedicated model.
+"""
+
+import os
+import json
+import pickle
+from functools import lru_cache
+from typing import Dict, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import xgboost as xgb
+
+AI_ENGINE_DIR    = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+LEAGUE_MODEL_DIR = os.path.join(AI_ENGINE_DIR, "models", "league_specific")
+
+# Market file name → (num_class, label_list)
+MARKET_META: Dict[str, Tuple[int, list]] = {
+    "ms":       (3, ["1", "X", "2"]),
+    "ou15":     (2, ["Over", "Under"]),
+    "ou25":     (2, ["Over", "Under"]),
+    "ou35":     (2, ["Over", "Under"]),
+    "btts":     (2, ["Yes", "No"]),
+    "ht":       (3, ["1", "X", "2"]),
+    "ht_ou05":  (2, ["Over", "Under"]),
+    "ht_ou15":  (2, ["Over", "Under"]),
+    "htft":     (9, ["1/1","1/X","1/2","X/1","X/X","X/2","2/1","2/X","2/2"]),
+    "oe":       (2, ["Odd", "Even"]),
+    "cards":    (2, ["Over", "Under"]),
+    "handicap": (3, ["1", "X", "2"]),
+}
+
+# Signal key map (file key → uppercase signal key used in _get_v25_signal)
+FILE_TO_SIGNAL = {
+    "ms": "MS", "ou15": "OU15", "ou25": "OU25", "ou35": "OU35",
+    "btts": "BTTS", "ht": "HT", "ht_ou05": "HT_OU05", "ht_ou15": "HT_OU15",
+    "htft": "HTFT", "oe": "OE", "cards": "CARDS", "handicap": "HCAP",
+}
+
+
+class LeagueModel:
+    """Holds XGBoost models + isotonic calibrators for one league."""
+
+    def __init__(self, league_id: str):
+        self.league_id = league_id
+        self.league_dir = os.path.join(LEAGUE_MODEL_DIR, league_id)
+        self.models: Dict[str, xgb.Booster] = {}       # market_key → booster
+        self.calibrators: Dict[str, object] = {}        # cal_key → isotonic
+        self.feature_cols: Optional[list] = None
+        self._loaded = False
+
+    def load(self) -> bool:
+        if not os.path.isdir(self.league_dir):
+            return False
+        try:
+            fc_path = os.path.join(self.league_dir, "feature_cols.json")
+            if os.path.exists(fc_path):
+                with open(fc_path) as f:
+                    self.feature_cols = json.load(f)
+
+            for mkey in MARKET_META:
+                xgb_path = os.path.join(self.league_dir, f"xgb_{mkey}.json")
+                if os.path.exists(xgb_path) and os.path.getsize(xgb_path) > 100:
+                    b = xgb.Booster()
+                    b.load_model(xgb_path)
+                    self.models[mkey] = b
+
+            for fname in os.listdir(self.league_dir):
+                if fname.startswith("cal_") and fname.endswith(".pkl"):
+                    cal_key = fname[4:-4]  # strip cal_ and .pkl
+                    with open(os.path.join(self.league_dir, fname), "rb") as f:
+                        self.calibrators[cal_key] = pickle.load(f)
+
+            self._loaded = bool(self.models or self.calibrators)
+            return self._loaded
+        except Exception as e:
+            print(f"[LeagueModel] Load failed for {self.league_id}: {e}")
+            return False
+
+    def has_market(self, mkey: str) -> bool:
+        return mkey in self.models
+
+    def predict_market(
+        self,
+        mkey: str,
+        feature_row: Dict[str, float],
+    ) -> Optional[Dict[str, float]]:
+        """
+        Predict one market using league-specific XGBoost + isotonic calibration.
+        Returns {label: prob} dict or None if no model available.
+        """
+        if mkey not in self.models:
+            return None
+
+        num_class, labels = MARKET_META[mkey]
+        fc = self.feature_cols
+        if fc is None:
+            # Fallback to whatever the booster expects (it knows its feature names)
+            fc = list(self.models[mkey].feature_names or [])
+
+        try:
+            X = pd.DataFrame([{col: feature_row.get(col, 0.0) for col in fc}])
+            dmat = xgb.DMatrix(X)
+            raw = self.models[mkey].predict(dmat)
+
+            if num_class > 2:
+                probs_arr = raw.reshape(-1, num_class)[0]
+                probs = {labels[i]: float(probs_arr[i]) for i in range(num_class)}
+                # Apply isotonic calibration per class
+                cal_total = 0.0
+                for i, label in enumerate(labels):
+                    cal_key = f"{mkey}_{i}"
+                    if cal_key in self.calibrators:
+                        p_cal = float(self.calibrators[cal_key].predict([probs_arr[i]])[0])
+                        probs[label] = max(0.01, min(0.99, p_cal))
+                    cal_total += probs[label]
+                if cal_total > 0:
+                    probs = {k: v / cal_total for k, v in probs.items()}
+            else:
+                p = float(raw[0])
+                cal_key = mkey
+                if cal_key in self.calibrators:
+                    p = float(self.calibrators[cal_key].predict([p])[0])
+                    p = max(0.01, min(0.99, p))
+                probs = {labels[0]: p, labels[1]: 1.0 - p}
+
+            return probs
+        except Exception as e:
+            print(f"[LeagueModel] predict_market({mkey}) failed for {self.league_id}: {e}")
+            return None
+
+
+class LeagueModelLoader:
+    """
+    In-memory cache for league-specific models.
+    Thread-safe for single-process async servers (FastAPI/uvicorn).
+    """
+
+    def __init__(self, max_cached: int = 80):
+        self._cache: Dict[str, Optional[LeagueModel]] = {}
+        self._max_cached = max_cached
+
+    def get(self, league_id: str) -> Optional[LeagueModel]:
+        """Return loaded LeagueModel for this league, or None if unavailable."""
+        if league_id in self._cache:
+            return self._cache[league_id]
+
+        # Evict oldest entry if cache is full
+        if len(self._cache) >= self._max_cached:
+            oldest = next(iter(self._cache))
+            del self._cache[oldest]
+
+        model = LeagueModel(league_id)
+        loaded = model.load()
+        self._cache[league_id] = model if loaded else None
+        if loaded:
+            n_models = len(model.models)
+            n_cals   = len(model.calibrators)
+            print(f"[LeagueModel] Loaded {league_id}: {n_models} XGB models, {n_cals} calibrators")
+        return self._cache[league_id]
+
+    def available_leagues(self) -> list:
+        if not os.path.isdir(LEAGUE_MODEL_DIR):
+            return []
+        return [d for d in os.listdir(LEAGUE_MODEL_DIR)
+                if os.path.isdir(os.path.join(LEAGUE_MODEL_DIR, d))]
+
+    def readiness_summary(self) -> dict:
+        leagues = self.available_leagues()
+        return {
+            "league_specific_dir": LEAGUE_MODEL_DIR,
+            "available_leagues": len(leagues),
+            "cached": len([v for v in self._cache.values() if v is not None]),
+        }
+
+
+# ── Singleton ──────────────────────────────────────────────────────
+_loader: Optional[LeagueModelLoader] = None
+
+
+def get_league_model_loader() -> LeagueModelLoader:
+    global _loader
+    if _loader is None:
+        _loader = LeagueModelLoader()
+    return _loader
@@ -0,0 +1,154 @@
+[
+  "home_overall_elo",
+  "away_overall_elo",
+  "elo_diff",
+  "home_home_elo",
+  "away_away_elo",
+  "home_form_elo",
+  "away_form_elo",
+  "form_elo_diff",
+  "home_goals_avg",
+  "home_conceded_avg",
+  "away_goals_avg",
+  "away_conceded_avg",
+  "home_clean_sheet_rate",
+  "away_clean_sheet_rate",
+  "home_scoring_rate",
+  "away_scoring_rate",
+  "home_winning_streak",
+  "away_winning_streak",
+  "home_unbeaten_streak",
+  "away_unbeaten_streak",
+  "h2h_total_matches",
+  "h2h_home_win_rate",
+  "h2h_draw_rate",
+  "h2h_avg_goals",
+  "h2h_btts_rate",
+  "h2h_over25_rate",
+  "home_avg_possession",
+  "away_avg_possession",
+  "home_avg_shots_on_target",
+  "away_avg_shots_on_target",
+  "home_shot_conversion",
+  "away_shot_conversion",
+  "home_avg_corners",
+  "away_avg_corners",
+  "odds_ms_h",
+  "odds_ms_d",
+  "odds_ms_a",
+  "implied_home",
+  "implied_draw",
+  "implied_away",
+  "odds_ht_ms_h",
+  "odds_ht_ms_d",
+  "odds_ht_ms_a",
+  "odds_ou05_o",
+  "odds_ou05_u",
+  "odds_ou15_o",
+  "odds_ou15_u",
+  "odds_ou25_o",
+  "odds_ou25_u",
+  "odds_ou35_o",
+  "odds_ou35_u",
+  "odds_ht_ou05_o",
+  "odds_ht_ou05_u",
+  "odds_ht_ou15_o",
+  "odds_ht_ou15_u",
+  "odds_btts_y",
+  "odds_btts_n",
+  "odds_ms_h_present",
+  "odds_ms_d_present",
+  "odds_ms_a_present",
+  "odds_ht_ms_h_present",
+  "odds_ht_ms_d_present",
+  "odds_ht_ms_a_present",
+  "odds_ou05_o_present",
+  "odds_ou05_u_present",
+  "odds_ou15_o_present",
+  "odds_ou15_u_present",
+  "odds_ou25_o_present",
+  "odds_ou25_u_present",
+  "odds_ou35_o_present",
+  "odds_ou35_u_present",
+  "odds_ht_ou05_o_present",
+  "odds_ht_ou05_u_present",
+  "odds_ht_ou15_o_present",
+  "odds_ht_ou15_u_present",
+  "odds_btts_y_present",
+  "odds_btts_n_present",
+  "home_xga",
+  "away_xga",
+  "league_avg_goals",
+  "league_zero_goal_rate",
+  "upset_atmosphere",
+  "upset_motivation",
+  "upset_fatigue",
+  "upset_potential",
+  "referee_home_bias",
+  "referee_avg_goals",
+  "referee_cards_total",
+  "referee_avg_yellow",
+  "referee_experience",
+  "home_momentum_score",
+  "away_momentum_score",
+  "momentum_diff",
+  "home_squad_quality",
+  "away_squad_quality",
+  "squad_diff",
+  "home_key_players",
+  "away_key_players",
+  "home_missing_impact",
+  "away_missing_impact",
+  "home_goals_form",
+  "away_goals_form",
+  "home_lineup_goals_per90",
+  "away_lineup_goals_per90",
+  "home_lineup_assists_per90",
+  "away_lineup_assists_per90",
+  "home_squad_continuity",
+  "away_squad_continuity",
+  "home_top_scorer_form",
+  "away_top_scorer_form",
+  "home_avg_player_exp",
+  "away_avg_player_exp",
+  "home_goals_diversity",
+  "away_goals_diversity",
+  "h2h_home_goals_avg",
+  "h2h_away_goals_avg",
+  "h2h_recent_trend",
+  "h2h_venue_advantage",
+  "home_rolling5_goals",
+  "home_rolling5_conceded",
+  "home_rolling10_goals",
+  "home_rolling10_conceded",
+  "home_rolling20_goals",
+  "home_rolling20_conceded",
+  "away_rolling5_goals",
+  "away_rolling5_conceded",
+  "away_rolling10_goals",
+  "away_rolling10_conceded",
+  "home_rolling5_cs",
+  "away_rolling5_cs",
+  "home_venue_goals",
+  "home_venue_conceded",
+  "away_venue_goals",
+  "away_venue_conceded",
+  "home_goal_trend",
+  "away_goal_trend",
+  "home_days_rest",
+  "away_days_rest",
+  "match_month",
+  "is_season_start",
+  "is_season_end",
+  "attack_vs_defense_home",
+  "attack_vs_defense_away",
+  "xg_diff",
+  "form_momentum_interaction",
+  "elo_form_consistency",
+  "upset_x_elo_gap",
+  "league_home_win_rate",
+  "league_draw_rate",
+  "league_btts_rate",
+  "league_ou25_rate",
+  "league_reliability_score"
+]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
fahricansecer	fa48f87f53	gg2 Deploy Iddaai Backend / build-and-deploy (push) Successful in 4m53s Details	2026-05-24 17:29:31 +03:00
fahricansecer	920ae7ce38	gg Deploy Iddaai Backend / build-and-deploy (push) Successful in 59s Details	2026-05-24 02:58:53 +03:00
fahricansecer	02f9aea333	gg Deploy Iddaai Backend / build-and-deploy (push) Successful in 28s Details	2026-05-24 02:49:08 +03:00
fahricansecer	15c6313246	Merge branch 'main' of https://gitea.bilgich.com/fahricansecer/iddaai-be Deploy Iddaai Backend / build-and-deploy (push) Successful in 54s Details	2026-05-24 02:44:52 +03:00
fahricansecer	1b420a425e	Update .gitignore	2026-05-24 02:43:10 +03:00
fahricansecer	55e62d8fe5	.gitea/workflows/deploy.yml Güncelle Deploy Iddaai Backend / build-and-deploy (push) Successful in 4m56s Details	2026-05-24 02:30:14 +03:00
fahricansecer	21e05148c8	feat: league tier system + retrained V25 models (48 quality leagues) Deploy Iddaai Backend / build-and-deploy (push) Failing after 3m56s Details - Add LeagueTier DB model and Prisma schema - Add league-tiers service (CRUD, sync, retrain trigger) - Add league-tiers controller with admin API endpoints - Add /v1/admin/retrain endpoint in AI engine (extract→train→reload pipeline) - Retrain V25 Pro with 48 quality leagues (MS accuracy: 26.9%→51.4%) - Update qualified_leagues.json (443→48 leagues) - Include V25 model files in repo for Docker deployment Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-20 21:57:15 +03:00
fahricansecer	e001ce9ab5	fix: guarantee iddaai-ai-engine network alias on every deploy Deploy Iddaai Backend / build-and-deploy (push) Successful in 29s Details	2026-05-20 10:40:00 +03:00
fahricansecer	9481ad7094	changes Deploy Iddaai Backend / build-and-deploy (push) Successful in 42s Details	2026-05-20 10:10:28 +03:00
fahricansecer	1d4aa36602	gg Deploy Iddaai Backend / build-and-deploy (push) Successful in 31s Details	2026-05-18 00:08:50 +03:00
fahricansecer	5574a3c59d	feat: separate commentary endpoint - non-blocking Ollama Deploy Iddaai Backend / build-and-deploy (push) Successful in 30s Details	2026-05-17 16:47:05 +03:00
fahricansecer	94c7a4481a	main Deploy Iddaai Backend / build-and-deploy (push) Successful in 37s Details	2026-05-17 02:17:22 +03:00
fahricansecer	17ace9bd12	feat: Ollama AI expert commentary integration Deploy Iddaai Backend / build-and-deploy (push) Successful in 37s Details - OllamaClient utility for llama3.2:3b API calls (timeout 30s, non-fatal) - OllamaCommentary service builds structured Turkish prompt from prediction data - PredictionsService enriches response with ai_expert_commentary field - Frontend prediction-card displays AI commentary section above match_commentary	2026-05-17 02:09:04 +03:00
fahricansecer	2b87669f41	gg Deploy Iddaai Backend / build-and-deploy (push) Successful in 31s Details	2026-05-13 16:56:14 +03:00
fahricansecer	2507678bc0	gg Deploy Iddaai Backend / build-and-deploy (push) Successful in 32s Details	2026-05-12 17:41:49 +03:00
fahricansecer	2b8dce665f	gg Deploy Iddaai Backend / build-and-deploy (push) Successful in 1m8s Details	2026-05-12 03:06:54 +03:00
fahricansecer	b6d64b59bf	main Deploy Iddaai Backend / build-and-deploy (push) Failing after 2m6s Details	2026-05-12 02:43:02 +03:00
fahricansecer	f8599bdb9a	gg Deploy Iddaai Backend / build-and-deploy (push) Failing after 2m1s Details	2026-05-11 23:11:41 +03:00
fahricansecer	4dcc4ced50	gg Deploy Iddaai Backend / build-and-deploy (push) Failing after 2m15s Details	2026-05-11 20:50:31 +03:00
fahricansecer	70fdc066c7	Merge branch 'v28' Deploy Iddaai Backend / build-and-deploy (push) Successful in 6s Details	2026-05-10 22:52:21 +03:00
fahricansecer	f3362f266c	gg	2026-05-10 22:52:05 +03:00
fahricansecer	8ce8fa5b94	Merge pull request 'gg' (#6 ) from v28 into main Deploy Iddaai Backend / build-and-deploy (push) Successful in 39s Details Reviewed-on: #6	2026-05-10 10:39:32 +03:00
fahricansecer	c525b12dfd	gg	2026-05-10 10:37:45 +03:00
fahricansecer	497b5d8d3b	Merge pull request 'feat(ai-engine): value sniper thresholds and logic relaxed' (#5 ) from v28 into main Deploy Iddaai Backend / build-and-deploy (push) Successful in 30s Details Reviewed-on: #5	2026-05-06 17:56:24 +03:00
fahricansecer	4f7090e2d9	feat(ai-engine): value sniper thresholds and logic relaxed	2026-05-06 17:44:45 +03:00
fahricansecer	5b5f83c8cf	fix(ai-engine): remove target leakage from training data extraction Deploy Iddaai Backend / build-and-deploy (push) Successful in 6s Details - goals_form now uses avg of last 5 historical matches instead of current match goals - squad_quality removes current match goals/assists, uses only pre-match known data - adds temporal filtering via match_id -> mst_utc mapping	2026-05-05 22:35:04 +03:00
fahricansecer	bfddcaca7d	gg Deploy Iddaai Backend / build-and-deploy (push) Successful in 6s Details	2026-05-05 21:27:06 +03:00
fahricansecer	56d560af08	Update single_match_orchestrator.py Deploy Iddaai Backend / build-and-deploy (push) Successful in 8s Details	2026-05-05 20:59:59 +03:00
fahricansecer	4bc51cfa99	fix(ai-engine): hoist ms_edge before score prediction branch to prevent UnboundLocalError Deploy Iddaai Backend / build-and-deploy (push) Successful in 5s Details	2026-05-05 20:34:14 +03:00
fahricansecer	fdb8a5d0f0	fix(ai-engine): sync FEATURE_COLS with trained models (82→102 features) Deploy Iddaai Backend / build-and-deploy (push) Successful in 6s Details - Load feature columns dynamically from feature_cols.json - Add 20 missing odds_*_present boolean flags to fallback list - Fixes LightGBM 'features in data (82) != training data (102)' crash	2026-05-05 20:29:55 +03:00
fahricansecer	22596e69f2	fix(predictions): circuit breaker resilience + graceful degradation Deploy Iddaai Backend / build-and-deploy (push) Successful in 27s Details - Reset consecutiveFailures on cooldown expiry (half-open state) so a single retry failure doesn't immediately re-open the circuit - Exclude AI Engine app-level 500s from circuit breaker count (only network/infra errors: timeout, 502, 503, 504, 429) - Return null gracefully instead of throwing 503 when no cache exists - Add DB fallback for non-cooldown AI Engine failures - Remove blocking wait-and-retry that held requests for up to 20s	2026-05-05 20:19:25 +03:00
fahricansecer	f32badbd8f	fix(predictions): cooldown fallback cascade + circuit breaker tuning Deploy Iddaai Backend / build-and-deploy (push) Successful in 27s Details - Add 4-level fallback when AI circuit breaker fires cooldown: 1) In-memory cache (10min TTL) 2) DB stored prediction (no TTL filter) 3) DB cached prediction (with model version check) 4) Wait out cooldown + retry once (max 20s wait) - Raise circuit breaker threshold from 3 to 5 consecutive failures - Reduce cooldown duration from 30s to 15s for faster recovery - Add extractCooldownMs helper to parse remaining ms from error detail	2026-05-05 20:11:19 +03:00
fahricansecer	5645b38f20	main Deploy Iddaai Backend / build-and-deploy (push) Successful in 32s Details	2026-05-05 17:09:11 +03:00
fahricansecer	244d8f5366	feat(ai): expand training to 68K+ matches, add score model, backfill implied odds Deploy Iddaai Backend / build-and-deploy (push) Successful in 6s Details - extract_training_data.py: switch from top_leagues.json (23) to qualified_leagues.json (265) - update_implied_odds.py: new script to backfill implied odds from real market data - train_score_model.py: rewrite with v25 102-feature set + temporal split - single_match_orchestrator.py: integrate ML score model with heuristic fallback	2026-05-05 16:04:00 +03:00
fahricansecer	9bb8f39bca	gg Deploy Iddaai Backend / build-and-deploy (push) Successful in 2m45s Details	2026-05-05 14:06:20 +03:00
fahricansecer	7a1cf14e2f	Update matches.service.ts Deploy Iddaai Backend / build-and-deploy (push) Successful in 28s Details	2026-05-05 10:47:00 +03:00
fahricansecer	62c797d299	Update matches.service.ts Deploy Iddaai Backend / build-and-deploy (push) Successful in 29s Details	2026-05-05 10:13:23 +03:00
fahricansecer	34cc4a6cbb	Update matches.service.ts Deploy Iddaai Backend / build-and-deploy (push) Successful in 30s Details	2026-05-05 01:04:56 +03:00
fahricansecer	27e96da31d	main Deploy Iddaai Backend / build-and-deploy (push) Successful in 29s Details	2026-05-04 18:00:40 +03:00
fahricansecer	145a8b336b	fix(feeder): preserve pre-match odds when match goes live Deploy Iddaai Backend / build-and-deploy (push) Successful in 29s Details Live odds have missing selections (e.g. '1' key removed from Maç Sonucu after kickoff), causing the AI model to produce wildly incorrect predictions (e.g. 3.5% home win for Bristol City). Two guards added: 1. fetchOddsForMatches: Exclude live/finished matches from odds fetch query 2. processMatchOdds: Skip odds/lineups/sidelined overwrite if match already has pre-match odds and is live/finished	2026-05-02 16:32:42 +03:00
fahricansecer	7a8960edb8	chore: remove debug checkpoint logs and temp SQL files Deploy Iddaai Backend / build-and-deploy (push) Successful in 37s Details	2026-04-26 17:09:22 +03:00
fahricansecer	691c52f610	perf: replace Prisma relation queries with raw SQL for getExistingMatchIds and getMissingScopes - fixes Pi hang Deploy Iddaai Backend / build-and-deploy (push) Successful in 39s Details	2026-04-26 17:07:19 +03:00
fahricansecer	bc461429f6	debug: add checkpoint timestamps to processDate for hang diagnosis Deploy Iddaai Backend / build-and-deploy (push) Successful in 46s Details	2026-04-26 17:04:46 +03:00
fahricansecer	a338d02244	main Deploy Iddaai Backend / build-and-deploy (push) Successful in 2m42s Details	2026-04-26 03:07:18 +03:00
fahricansecer	1623432039	fix: watchdog force-kill with SIGKILL fallback when process.exit is blocked	2026-04-26 02:27:51 +03:00
fahricansecer	4c7930e9d2	feat: add watchdog timer to detect and recover from hung API requests Deploy Iddaai Backend / build-and-deploy (push) Successful in 27s Details	2026-04-25 11:20:30 +03:00
fahricansecer	ec463cb927	fix: make canvas import optional for ARM64 compatibility	2026-04-25 02:41:53 +03:00
fahricansecer	eab95c4e5c	Update feeder.service.ts Deploy Iddaai Backend / build-and-deploy (push) Successful in 30s Details	2026-04-25 02:23:38 +03:00
fahricansecer	9027cc9900	v28 Deploy Iddaai Backend / build-and-deploy (push) Successful in 3m21s Details	2026-04-24 23:46:28 +03:00
fahricansecer	3875f2a512	Create v28-pro-max-architecture.md Deploy Iddaai Backend / build-and-deploy (push) Successful in 27s Details	2026-04-24 02:30:26 +03:00
fahricansecer	300dceeb4b	Merge branch 'main' of https://gitea.bilgich.com/fahricansecer/iddaai-be Deploy Iddaai Backend / build-and-deploy (push) Successful in 27s Details	2026-04-24 02:10:48 +03:00
fahricansecer	ad01976fb9	fix: lineup data normalization + tomorrow match sync + player field mapping	2026-04-24 02:09:58 +03:00
fahricansecer	6880eb92f5	Merge pull request 'v26-shadow' (#4 ) from v26-shadow into main Deploy Iddaai Backend / build-and-deploy (push) Successful in 27s Details Reviewed-on: #4	2026-04-24 01:15:54 +03:00
fahricansecer	9e2edd590c	Merge branch 'main' into v26-shadow	2026-04-24 01:15:18 +03:00
fahricansecer	b5c2edf346	gg	2026-04-24 01:15:05 +03:00
fahricansecer	bf7473c1e7	Merge pull request 'fix: update version tags to v28 and temporarily disable cache for predictions' (#3 ) from v26-shadow into main Deploy Iddaai Backend / build-and-deploy (push) Successful in 31s Details Reviewed-on: #3	2026-04-24 00:30:55 +03:00
fahricansecer	1f26a5bf2f	fix: update version tags to v28 and temporarily disable cache for predictions	2026-04-24 00:11:00 +03:00
fahricansecer	fb53fdf1df	Merge pull request 'v26-shadow' (#2 ) from v26-shadow into main Deploy Iddaai Backend / build-and-deploy (push) Successful in 2m51s Details Reviewed-on: #2	2026-04-23 22:29:23 +03:00
fahricansecer	634204acf0	v28	2026-04-23 22:22:59 +03:00
fahricansecer	df428ed1e8	gg	2026-04-22 02:17:02 +03:00
fahricansecer	2ccd6831eb	gg	2026-04-21 16:53:56 +03:00
fahricansecer	1346924387	gg	2026-04-19 13:23:00 +03:00
fahricansecer	e4c74025e5	Merge pull request 'cron' (#1 ) from cron into main Deploy Iddaai Backend / build-and-deploy (push) Successful in 2m48s Details Reviewed-on: #1	2026-04-16 17:22:36 +03:00
fahricansecer	c8e7e4e927	cr	2026-04-16 17:21:48 +03:00
Gitea Actions	c8fa4c442d	chore: add docker info	2026-04-16 12:20:56 +00:00
fahricansecer	0f917695dd	chore: add workflow Check Docker Pi / check-docker (push) Successful in 6s Details	2026-04-16 15:20:42 +03:00
fahricansecer	249c57346e	first (part 4: residual files) Deploy Iddaai Backend / build-and-deploy (push) Successful in 26s Details	2026-04-16 15:13:24 +03:00
fahricansecer	182f4aae16	first (part 3: src directory) Deploy Iddaai Backend / build-and-deploy (push) Successful in 33s Details	2026-04-16 15:12:27 +03:00
fahricansecer	2f0b85a0c7	first (part 2: other directories) Deploy Iddaai Backend / build-and-deploy (push) Failing after 18s Details	2026-04-16 15:11:25 +03:00
fahricansecer	7814e0bc6b	first (part 1: root files) Deploy Iddaai Backend / build-and-deploy (push) Failing after 4s Details	2026-04-16 15:09:10 +03:00