cbazzaandClaude Sonnet 4.5
f6106b8333
This project includes multiple AI/ML-based lottery number generators for German Lotto 6aus49, including pattern analysis, weighted predictions, and hybrid approaches. Features automated weekly tip generation, performance tracking, and Telegram bot integration. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
842 lines
36 KiB
Python
842 lines
36 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
SUPER-LOTTO 6AUS49 GENERATOR
|
|
Mit vollständigen historischen Daten und nie gezogenen Kombinationen
|
|
|
|
Nutzt Sebastian's komplette Datenbasis:
|
|
- AlleLottozahlen.csv: Alle historischen Ziehungen mit Multi-Trend-Analyse
|
|
- Fehlende_Lotto_Kombinationen.csv: Alle nie gezogenen Kombinationen
|
|
- Maximale Optimierung durch vollständige Datenbasis
|
|
"""
|
|
|
|
import pandas as pd
|
|
import numpy as np
|
|
import random
|
|
from collections import Counter, defaultdict
|
|
import datetime
|
|
import pickle
|
|
import os
|
|
|
|
class SuperLotto6aus49Generator:
|
|
def __init__(self):
|
|
# Pfade zu Sebastian's Daten
|
|
self.base_path = "/Users/sebastianfrohlich/Library/Mobile Documents/com~apple~CloudDocs/Jupyter Notebooks"
|
|
self.historical_data_path = f"{self.base_path}/AlleLottozahlen.csv"
|
|
self.unused_combinations_path = f"{self.base_path}/Fehlende_Lotto_Kombinationen.csv"
|
|
|
|
# Daten-Container
|
|
self.df_historical = None
|
|
self.df_unused = None
|
|
self.drawn_combinations = set()
|
|
|
|
# Basis-Analysen
|
|
self.number_frequencies = Counter()
|
|
self.position_frequencies = defaultdict(Counter)
|
|
self.pattern_frequencies = Counter()
|
|
self.supernumber_frequencies = Counter()
|
|
self.weekday_frequencies = Counter()
|
|
|
|
# Multi-Trend-Analysen
|
|
self.number_sequences = defaultdict(list)
|
|
self.momentum_scores = {}
|
|
self.trend_predictions = {}
|
|
self.sequential_dependencies = defaultdict(lambda: defaultdict(int))
|
|
self.hot_numbers = []
|
|
self.warm_numbers = []
|
|
self.cold_numbers = []
|
|
|
|
# Unused Combinations Intelligence
|
|
self.unused_combinations_sample = []
|
|
self.unused_patterns = Counter()
|
|
self.unused_by_ranges = {'N': [], 'M': [], 'H': []}
|
|
|
|
# Cache für Performance
|
|
self.cache_file = f"{self.base_path}/super_lotto_cache.pkl"
|
|
|
|
print("🚀 SUPER-LOTTO 6AUS49 GENERATOR")
|
|
print("=" * 50)
|
|
print("📊 Lade vollständige Sebastian's Datenbasis...")
|
|
|
|
# Lade und analysiere alle Daten
|
|
self.load_all_data()
|
|
|
|
def load_all_data(self):
|
|
"""Lädt alle verfügbaren Daten und führt komplette Analyse durch."""
|
|
|
|
# 1. Historische Ziehungen laden
|
|
print("📈 Lade historische Ziehungen...")
|
|
self._load_historical_data()
|
|
|
|
# 2. Nie gezogene Kombinationen laden
|
|
print("🎯 Lade nie gezogene Kombinationen...")
|
|
self._load_unused_combinations()
|
|
|
|
# 3. Basis-Analysen
|
|
print("🔍 Führe Basis-Analysen durch...")
|
|
self._perform_basic_analysis()
|
|
|
|
# 4. Multi-Trend-Analysen
|
|
print("📊 Multi-Trend-Analyse...")
|
|
self._perform_momentum_analysis()
|
|
self._perform_sequential_analysis()
|
|
|
|
# 5. Unused Combinations Intelligence
|
|
print("🎲 Analysiere nie gezogene Kombinationen...")
|
|
self._analyze_unused_combinations()
|
|
|
|
print("✅ Komplette Super-Analyse abgeschlossen!")
|
|
self._print_super_analysis_summary()
|
|
|
|
def _load_historical_data(self):
|
|
"""Lädt historische Lotto-Daten."""
|
|
try:
|
|
# Sebastian's Format: tag;datum;Z1;Z2;Z3;Z4;Z5;Z6;SZ
|
|
self.df_historical = pd.read_csv(self.historical_data_path, sep=';')
|
|
|
|
# Datum konvertieren (verschiedene Formate unterstützen)
|
|
date_formats = ['%Y-%m-%d', '%d.%m.%Y', '%d/%m/%Y']
|
|
for date_format in date_formats:
|
|
try:
|
|
self.df_historical['datum'] = pd.to_datetime(self.df_historical['datum'], format=date_format)
|
|
break
|
|
except:
|
|
continue
|
|
|
|
# Sortiere chronologisch (älteste zuerst für Trend-Analyse)
|
|
self.df_historical = self.df_historical.sort_values('datum')
|
|
|
|
print(f"✅ {len(self.df_historical)} historische Ziehungen geladen")
|
|
print(f"📅 Zeitraum: {self.df_historical['datum'].min()} bis {self.df_historical['datum'].max()}")
|
|
|
|
except Exception as e:
|
|
print(f"❌ Fehler beim Laden historischer Daten: {e}")
|
|
return False
|
|
|
|
return True
|
|
|
|
def _load_unused_combinations(self):
|
|
"""Lädt alle nie gezogenen Kombinationen."""
|
|
try:
|
|
# Große Datei in Chunks laden für bessere Performance
|
|
chunk_size = 100000
|
|
chunks = []
|
|
|
|
print("⏳ Lade nie gezogene Kombinationen (große Datei)...")
|
|
|
|
for chunk in pd.read_csv(self.unused_combinations_path, sep=';', chunksize=chunk_size):
|
|
chunks.append(chunk)
|
|
if len(chunks) % 50 == 0:
|
|
print(f" 📊 {len(chunks) * chunk_size:,} Kombinationen geladen...")
|
|
|
|
self.df_unused = pd.concat(chunks, ignore_index=True)
|
|
|
|
print(f"✅ {len(self.df_unused):,} nie gezogene Kombinationen verfügbar!")
|
|
print(f"💡 Das sind {len(self.df_unused)/13983816*100:.1f}% aller möglichen Kombinationen")
|
|
|
|
# Sample für Performance (arbeiten mit repräsentativem Subset)
|
|
sample_size = min(500000, len(self.df_unused)) # Max 500k für Performance
|
|
self.unused_combinations_sample = self.df_unused.sample(n=sample_size, random_state=42)
|
|
|
|
print(f"🎯 Arbeite mit {len(self.unused_combinations_sample):,} Sample-Kombinationen")
|
|
|
|
except Exception as e:
|
|
print(f"❌ Fehler beim Laden nie gezogener Kombinationen: {e}")
|
|
return False
|
|
|
|
return True
|
|
|
|
def _perform_basic_analysis(self):
|
|
"""Basis-Analyse der historischen Daten."""
|
|
|
|
for _, row in self.df_historical.iterrows():
|
|
# Gezogene Kombinationen
|
|
numbers = [row['Z1'], row['Z2'], row['Z3'], row['Z4'], row['Z5'], row['Z6']]
|
|
combo = tuple(sorted(numbers))
|
|
self.drawn_combinations.add(combo)
|
|
|
|
# Zahlenfrequenzen
|
|
for num in numbers:
|
|
self.number_frequencies[num] += 1
|
|
|
|
# Positionsfrequenzen
|
|
sorted_numbers = sorted(numbers)
|
|
for i, num in enumerate(sorted_numbers):
|
|
self.position_frequencies[f'pos_{i+1}'][num] += 1
|
|
|
|
# Muster-Analyse
|
|
pattern = self._get_pattern(sorted_numbers)
|
|
self.pattern_frequencies[pattern] += 1
|
|
|
|
# Superzahl
|
|
if 'SZ' in row and pd.notna(row['SZ']):
|
|
self.supernumber_frequencies[int(row['SZ'])] += 1
|
|
|
|
# Wochentag-Analyse
|
|
if 'tag' in row:
|
|
weekday = row['tag'].replace('.', '').replace(';', '')
|
|
self.weekday_frequencies[weekday] += 1
|
|
|
|
def _perform_momentum_analysis(self, window_size=20):
|
|
"""Erweiterte Momentum-Analyse mit größerem Fenster."""
|
|
print(f"🔥 Super-Momentum-Analyse (Fenster: {window_size})")
|
|
|
|
# Zahlensequenzen aufbauen
|
|
for number in range(1, 50):
|
|
sequence = []
|
|
for _, row in self.df_historical.iterrows():
|
|
drawn_numbers = [row['Z1'], row['Z2'], row['Z3'], row['Z4'], row['Z5'], row['Z6']]
|
|
sequence.append(1 if number in drawn_numbers else 0)
|
|
self.number_sequences[number] = sequence
|
|
|
|
# Super-Momentum-Scores
|
|
for number in range(1, 50):
|
|
recent_sequence = self.number_sequences[number][-window_size:]
|
|
|
|
hit_rate = sum(recent_sequence) / len(recent_sequence)
|
|
trend_score = self._calculate_trend_score(recent_sequence)
|
|
recency_score = self._calculate_recency_score(recent_sequence)
|
|
acceleration_score = self._calculate_acceleration_score(recent_sequence)
|
|
|
|
# Super-Momentum mit Beschleunigung
|
|
momentum_score = (hit_rate * 0.35) + (trend_score * 0.3) + \
|
|
(recency_score * 0.2) + (acceleration_score * 0.15)
|
|
|
|
self.momentum_scores[number] = {
|
|
'hit_rate': hit_rate,
|
|
'trend_score': trend_score,
|
|
'recency_score': recency_score,
|
|
'acceleration_score': acceleration_score,
|
|
'momentum_score': momentum_score,
|
|
'status': self._get_momentum_status(momentum_score)
|
|
}
|
|
|
|
# Kategorisierung
|
|
sorted_momentum = sorted(self.momentum_scores.items(),
|
|
key=lambda x: x[1]['momentum_score'], reverse=True)
|
|
|
|
self.hot_numbers = [num for num, data in sorted_momentum[:15]
|
|
if data['momentum_score'] > 0.3]
|
|
self.warm_numbers = [num for num, data in sorted_momentum[15:30]
|
|
if 0.2 <= data['momentum_score'] <= 0.3]
|
|
self.cold_numbers = [num for num, data in sorted_momentum[30:]
|
|
if data['momentum_score'] < 0.2]
|
|
|
|
print(f"🔥 {len(self.hot_numbers)} super-heiße Zahlen")
|
|
print(f"🌡️ {len(self.warm_numbers)} warme Zahlen")
|
|
print(f"🧊 {len(self.cold_numbers)} kalte Zahlen")
|
|
|
|
def _calculate_acceleration_score(self, sequence):
|
|
"""Berechnet Beschleunigung der Treffer (NEU!)."""
|
|
if len(sequence) < 4:
|
|
return 0
|
|
|
|
# Teile Sequenz in zwei Hälften
|
|
mid = len(sequence) // 2
|
|
first_half_rate = sum(sequence[:mid]) / mid
|
|
second_half_rate = sum(sequence[mid:]) / (len(sequence) - mid)
|
|
|
|
# Beschleunigung = Verbesserung in zweiter Hälfte
|
|
acceleration = second_half_rate - first_half_rate
|
|
return max(0, acceleration) # Nur positive Beschleunigung
|
|
|
|
def _perform_sequential_analysis(self):
|
|
"""Sequenzielle Abhängigkeiten zwischen Ziehungen."""
|
|
print("🔗 Super-Sequential-Analyse")
|
|
|
|
for i in range(3, len(self.df_historical)):
|
|
current_numbers = set([self.df_historical.iloc[i]['Z1'], self.df_historical.iloc[i]['Z2'],
|
|
self.df_historical.iloc[i]['Z3'], self.df_historical.iloc[i]['Z4'],
|
|
self.df_historical.iloc[i]['Z5'], self.df_historical.iloc[i]['Z6']])
|
|
|
|
for j in range(1, 4): # 3 Ziehungen zurück
|
|
prev_numbers = set([self.df_historical.iloc[i-j]['Z1'], self.df_historical.iloc[i-j]['Z2'],
|
|
self.df_historical.iloc[i-j]['Z3'], self.df_historical.iloc[i-j]['Z4'],
|
|
self.df_historical.iloc[i-j]['Z5'], self.df_historical.iloc[i-j]['Z6']])
|
|
|
|
for prev_num in prev_numbers:
|
|
for curr_num in current_numbers:
|
|
self.sequential_dependencies[f"lag_{j}"][f"{prev_num}_{curr_num}"] += 1
|
|
|
|
def _analyze_unused_combinations(self):
|
|
"""Analysiert nie gezogene Kombinationen für Intelligence."""
|
|
print("🎯 Super-Intelligence für nie gezogene Kombinationen")
|
|
|
|
# Muster der nie gezogenen Kombinationen
|
|
for _, row in self.unused_combinations_sample.iterrows():
|
|
numbers = [row['Z1'], row['Z2'], row['Z3'], row['Z4'], row['Z5'], row['Z6']]
|
|
pattern = self._get_pattern(numbers)
|
|
self.unused_patterns[pattern] += 1
|
|
|
|
# Verteilung nach N/M/H-Bereichen
|
|
for num in numbers:
|
|
if 1 <= num <= 16:
|
|
self.unused_by_ranges['N'].append(num)
|
|
elif 17 <= num <= 32:
|
|
self.unused_by_ranges['M'].append(num)
|
|
else:
|
|
self.unused_by_ranges['H'].append(num)
|
|
|
|
print(f"📊 Nie gezogene Muster analysiert:")
|
|
for pattern, count in self.unused_patterns.most_common(5):
|
|
percentage = (count / len(self.unused_combinations_sample)) * 100
|
|
print(f" {pattern}: {percentage:.1f}%")
|
|
|
|
def generate_super_combination(self):
|
|
"""Generiert Super-Kombination mit kompletter Intelligence."""
|
|
max_attempts = 2000
|
|
|
|
for attempt in range(max_attempts):
|
|
numbers = []
|
|
|
|
# Super-Strategie:
|
|
# 40% aus nie gezogenen hot trends
|
|
# 30% aus momentum analysis
|
|
# 20% aus sequential dependencies
|
|
# 10% random balance
|
|
|
|
# 2-3 Zahlen aus hot numbers mit unused combination bias
|
|
hot_unused_candidates = []
|
|
for combo_idx in range(min(10000, len(self.unused_combinations_sample))):
|
|
combo = self.unused_combinations_sample.iloc[combo_idx]
|
|
combo_numbers = [combo['Z1'], combo['Z2'], combo['Z3'], combo['Z4'], combo['Z5'], combo['Z6']]
|
|
hot_in_combo = [n for n in combo_numbers if n in self.hot_numbers[:10]]
|
|
if len(hot_in_combo) >= 2:
|
|
hot_unused_candidates.extend(hot_in_combo)
|
|
|
|
if hot_unused_candidates:
|
|
hot_picks = random.sample(list(set(hot_unused_candidates)), min(3, len(set(hot_unused_candidates))))
|
|
numbers.extend(hot_picks)
|
|
|
|
# 2 Zahlen aus Trend-Predictions
|
|
trend_candidates = [num for num, data in sorted(self.momentum_scores.items(),
|
|
key=lambda x: x[1]['momentum_score'], reverse=True)[:12]]
|
|
remaining_trend = [n for n in trend_candidates if n not in numbers]
|
|
if len(remaining_trend) >= 2:
|
|
trend_picks = random.sample(remaining_trend, 2)
|
|
numbers.extend(trend_picks)
|
|
|
|
# 1 Zahl für Balance
|
|
remaining_slots = 6 - len(numbers)
|
|
if remaining_slots > 0:
|
|
balance_candidates = self.warm_numbers + self.cold_numbers[:8]
|
|
remaining_balance = [n for n in balance_candidates if n not in numbers]
|
|
if remaining_balance:
|
|
balance_picks = random.sample(remaining_balance, min(remaining_slots, len(remaining_balance)))
|
|
numbers.extend(balance_picks)
|
|
|
|
# Auffüllen falls nötig
|
|
while len(numbers) < 6:
|
|
available = [n for n in range(1, 50) if n not in numbers]
|
|
additional = random.choice(available)
|
|
numbers.append(additional)
|
|
|
|
numbers = sorted(numbers[:6])
|
|
|
|
# Super-Validierung
|
|
if self._validate_super_combination(numbers):
|
|
return numbers
|
|
|
|
# Fallback
|
|
return self._generate_super_fallback()
|
|
|
|
def _validate_super_combination(self, numbers):
|
|
"""Super-Validierung mit unused combinations check."""
|
|
combo_tuple = tuple(sorted(numbers))
|
|
|
|
# Prüfe ob in historischen Daten (sollte nicht sein)
|
|
if combo_tuple in self.drawn_combinations:
|
|
return False
|
|
|
|
# Prüfe ob in unused combinations (sollte sein!)
|
|
unused_check = False
|
|
sample_size = min(50000, len(self.unused_combinations_sample))
|
|
for i in range(sample_size):
|
|
row = self.unused_combinations_sample.iloc[i]
|
|
unused_combo = tuple(sorted([row['Z1'], row['Z2'], row['Z3'], row['Z4'], row['Z5'], row['Z6']]))
|
|
if combo_tuple == unused_combo:
|
|
unused_check = True
|
|
break
|
|
|
|
# Basis-Validierungen
|
|
if len(set(numbers)) != 6:
|
|
return False
|
|
|
|
distances = [numbers[i+1] - numbers[i] for i in range(5)]
|
|
if min(distances) < 1 or max(distances) > 18:
|
|
return False
|
|
|
|
even_count = sum(1 for n in numbers if n % 2 == 0)
|
|
if even_count == 0 or even_count == 6:
|
|
return False
|
|
|
|
total = sum(numbers)
|
|
if total < 90 or total > 200:
|
|
return False
|
|
|
|
# Super-Check: Mindestens 1 hot number
|
|
hot_count = sum(1 for n in numbers if n in self.hot_numbers)
|
|
if hot_count == 0:
|
|
return False
|
|
|
|
return True
|
|
|
|
def _generate_super_fallback(self):
|
|
"""Super-Fallback mit unused combinations."""
|
|
# Wähle zufällig aus unused combinations
|
|
random_idx = random.randint(0, len(self.unused_combinations_sample) - 1)
|
|
row = self.unused_combinations_sample.iloc[random_idx]
|
|
return sorted([row['Z1'], row['Z2'], row['Z3'], row['Z4'], row['Z5'], row['Z6']])
|
|
|
|
def get_super_supernumber(self):
|
|
"""Super-optimierte Superzahl."""
|
|
if not self.supernumber_frequencies:
|
|
return random.randint(0, 9)
|
|
|
|
# Erweiterte Trend-Analyse für Superzahl
|
|
recent_data = self.df_historical.tail(15)
|
|
trend_scores = {}
|
|
|
|
for sz in range(0, 10):
|
|
recent_count = (recent_data['SZ'] == sz).sum() if 'SZ' in recent_data.columns else 0
|
|
total_count = self.supernumber_frequencies[sz]
|
|
|
|
# Multi-Faktor Score
|
|
trend_score = (recent_count / len(recent_data)) * 0.5 + \
|
|
(total_count / len(self.df_historical)) * 0.3 + \
|
|
(sz % 2) * 0.1 + \
|
|
(1 if sz in [0, 3, 7] else 0) * 0.1 # Beliebte Zahlen-Bonus
|
|
|
|
trend_scores[sz] = trend_score
|
|
|
|
# Gewichtete Auswahl
|
|
candidates = list(trend_scores.keys())
|
|
weights = list(trend_scores.values())
|
|
|
|
return random.choices(candidates, weights=weights)[0]
|
|
|
|
def generate_super_tips(self, num_tips=10):
|
|
"""Generiert Super-Tipps mit kompletter Intelligence."""
|
|
print(f"\n🚀 SUPER-TIPP-GENERIERUNG")
|
|
print("=" * 50)
|
|
print(f"🎯 Nutzt KOMPLETTE Sebastian's Datenbasis:")
|
|
print(f" 📈 {len(self.df_historical)} historische Ziehungen")
|
|
print(f" 🎲 {len(self.df_unused):,} nie gezogene Kombinationen")
|
|
print(f" 🔥 Super-Momentum-Analyse")
|
|
print(f" 🧠 Unused-Combinations-Intelligence")
|
|
|
|
generated_tips = []
|
|
strategy_stats = {
|
|
'unused_combo_hits': 0,
|
|
'hot_number_avg': 0,
|
|
'momentum_scores': []
|
|
}
|
|
|
|
print(f"\n🎲 GENERIERE {num_tips} SUPER-TIPPS:")
|
|
print("=" * 70)
|
|
print(f"{'Nr':<3} {'6 Super-Zahlen':<25} {'SZ':<3} {'🔥':<3} {'🎯':<3} {'Status'}")
|
|
print("-" * 70)
|
|
|
|
attempts = 0
|
|
max_attempts = num_tips * 100
|
|
|
|
while len(generated_tips) < num_tips and attempts < max_attempts:
|
|
attempts += 1
|
|
|
|
combination = self.generate_super_combination()
|
|
|
|
if combination and tuple(combination) not in [tuple(tip['zahlen']) for tip in generated_tips]:
|
|
# Analyse der Kombination
|
|
hot_count = sum(1 for n in combination if n in self.hot_numbers)
|
|
momentum_avg = np.mean([self.momentum_scores[n]['momentum_score'] for n in combination])
|
|
|
|
# Check ob in unused combinations
|
|
combo_tuple = tuple(sorted(combination))
|
|
unused_hit = False
|
|
for i in range(min(10000, len(self.unused_combinations_sample))):
|
|
row = self.unused_combinations_sample.iloc[i]
|
|
if combo_tuple == tuple(sorted([row['Z1'], row['Z2'], row['Z3'], row['Z4'], row['Z5'], row['Z6']])):
|
|
unused_hit = True
|
|
strategy_stats['unused_combo_hits'] += 1
|
|
break
|
|
|
|
superzahl = self.get_super_supernumber()
|
|
pattern = self._get_pattern(combination)
|
|
|
|
tip = {
|
|
'tipp_nr': len(generated_tips) + 1,
|
|
'zahlen': combination,
|
|
'z1': combination[0], 'z2': combination[1], 'z3': combination[2],
|
|
'z4': combination[3], 'z5': combination[4], 'z6': combination[5],
|
|
'superzahl': superzahl,
|
|
'hot_count': hot_count,
|
|
'momentum_avg': momentum_avg,
|
|
'unused_hit': unused_hit,
|
|
'pattern': pattern,
|
|
'super_score': hot_count * 0.4 + momentum_avg * 0.6
|
|
}
|
|
|
|
generated_tips.append(tip)
|
|
strategy_stats['hot_number_avg'] += hot_count
|
|
strategy_stats['momentum_scores'].append(momentum_avg)
|
|
|
|
# Status
|
|
status = "🎯 UNUSED!" if unused_hit else "📊 TREND"
|
|
zahlen_str = f"{combination[0]:2}-{combination[1]:2}-{combination[2]:2}-{combination[3]:2}-{combination[4]:2}-{combination[5]:2}"
|
|
print(f"{len(generated_tips):2}. {zahlen_str:<25} {superzahl:<3} {hot_count:<3} {momentum_avg:.2f} {status}")
|
|
|
|
# Super-Zusammenfassung
|
|
self._print_super_summary(generated_tips, strategy_stats, attempts)
|
|
|
|
# Export
|
|
self._export_super_tips(generated_tips)
|
|
|
|
return generated_tips
|
|
|
|
def _print_super_summary(self, tips, stats, attempts):
|
|
"""Super-Zusammenfassung."""
|
|
print(f"\n🏆 SUPER-LOTTO ZUSAMMENFASSUNG:")
|
|
print("=" * 45)
|
|
print(f"✅ {len(tips)} Super-Tipps generiert")
|
|
print(f"🎯 {stats['unused_combo_hits']}/{len(tips)} aus nie gezogenen Kombinationen")
|
|
print(f"🔥 Ø {stats['hot_number_avg']/len(tips):.1f} heiße Zahlen pro Tipp")
|
|
print(f"📊 Ø Momentum-Score: {np.mean(stats['momentum_scores']):.3f}")
|
|
print(f"⚡ Erfolgsrate: {len(tips)/attempts*100:.1f}%")
|
|
|
|
# Super-Intelligence Insights
|
|
print(f"\n💡 SUPER-INTELLIGENCE INSIGHTS:")
|
|
print("=" * 40)
|
|
|
|
# Top Momentum-Zahlen
|
|
top_momentum = sorted(self.momentum_scores.items(),
|
|
key=lambda x: x[1]['momentum_score'], reverse=True)[:8]
|
|
print(f"🔥 TOP MOMENTUM-ZAHLEN:")
|
|
for i, (num, data) in enumerate(top_momentum):
|
|
print(f" {i+1}. Zahl {num:2}: {data['momentum_score']:.3f} {data['status']}")
|
|
|
|
# Pattern-Verteilung nie gezogener Kombinationen
|
|
print(f"\n🎨 NIE GEZOGENE MUSTER (häufigste):")
|
|
for pattern, count in self.unused_patterns.most_common(3):
|
|
percentage = (count / len(self.unused_combinations_sample)) * 100
|
|
print(f" {pattern}: {percentage:.1f}% nie gezogen")
|
|
|
|
# Super-Empfehlungen
|
|
print(f"\n🚀 SUPER-EMPFEHLUNGEN:")
|
|
print(f" 🎯 {stats['unused_combo_hits']} Tipps stammen aus nie gezogenen Kombinationen")
|
|
print(f" 🔥 Fokus auf Top-{len(self.hot_numbers)} Momentum-Zahlen")
|
|
print(f" 📊 Nutzt {len(self.df_historical)} historische Ziehungen für Trends")
|
|
print(f" 💎 Maximale Optimierung durch {len(self.df_unused):,} nie gezogene Kombinationen!")
|
|
|
|
def _export_super_tips(self, tips):
|
|
"""Exportiert Super-Tipps."""
|
|
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
output_file = f"{self.base_path}/super_lotto_tipps_{timestamp}.csv"
|
|
|
|
# Erweiterte Export-Daten
|
|
export_data = []
|
|
for tip in tips:
|
|
tip_data = tip.copy()
|
|
tip_data['momentum_scores'] = [self.momentum_scores[n]['momentum_score'] for n in tip['zahlen']]
|
|
tip_data['individual_status'] = [self.momentum_scores[n]['status'] for n in tip['zahlen']]
|
|
export_data.append(tip_data)
|
|
|
|
df_export = pd.DataFrame(export_data)
|
|
df_export.to_csv(output_file, sep=';', index=False)
|
|
|
|
print(f"\n💾 SUPER-EXPORT:")
|
|
print("=" * 25)
|
|
print(f"✅ Super-Tipps gespeichert: super_lotto_tipps_{timestamp}.csv")
|
|
print(f"🚀 Basiert auf kompletter Sebastian's Datenbasis")
|
|
print(f"📊 Mit nie gezogenen Kombinationen optimiert")
|
|
|
|
def _print_super_analysis_summary(self):
|
|
"""Super-Analyse Zusammenfassung."""
|
|
print(f"\n📈 SUPER-ANALYSE ZUSAMMENFASSUNG:")
|
|
print("=" * 50)
|
|
|
|
# Datenbasis-Info
|
|
print(f"📊 DATENBASIS:")
|
|
print(f" 📈 Historische Ziehungen: {len(self.df_historical):,}")
|
|
print(f" 🎲 Nie gezogene Kombinationen: {len(self.df_unused):,}")
|
|
print(f" 📅 Zeitraum: {len(self.df_historical)} Ziehungen")
|
|
|
|
# Top Zahlen mit Super-Intelligence
|
|
print(f"\n🔥 SUPER-HOT ZAHLEN:")
|
|
for i, num in enumerate(self.hot_numbers[:8]):
|
|
momentum_data = self.momentum_scores[num]
|
|
freq = self.number_frequencies[num]
|
|
print(f" {i+1}. Zahl {num:2}: Score {momentum_data['momentum_score']:.3f} "
|
|
f"({freq}x gezogen) {momentum_data['status']}")
|
|
|
|
# Nie gezogene Muster-Intelligence
|
|
print(f"\n🎯 NIE GEZOGENE MUSTER-INTELLIGENCE:")
|
|
for pattern, count in self.unused_patterns.most_common(5):
|
|
historical_count = self.pattern_frequencies.get(pattern, 0)
|
|
unused_percentage = (count / len(self.unused_combinations_sample)) * 100
|
|
print(f" {pattern}: {unused_percentage:.1f}% nie gezogen "
|
|
f"(historisch: {historical_count}x)")
|
|
|
|
# Sequential Dependencies Insights
|
|
print(f"\n🔗 SEQUENTIAL INSIGHTS:")
|
|
if self.sequential_dependencies:
|
|
top_sequence = None
|
|
max_count = 0
|
|
for lag, transitions in self.sequential_dependencies.items():
|
|
for transition, count in transitions.items():
|
|
if count > max_count:
|
|
max_count = count
|
|
top_sequence = (lag, transition, count)
|
|
|
|
if top_sequence:
|
|
lag, transition, count = top_sequence
|
|
prev_num, curr_num = transition.split('_')
|
|
print(f" Stärkste Abhängigkeit: Nach Zahl {prev_num} kommt oft Zahl {curr_num} ({count}x)")
|
|
|
|
# Hilfsfunktionen
|
|
def _get_pattern(self, numbers):
|
|
"""N/M/H-Muster für 6aus49."""
|
|
pattern = []
|
|
for num in numbers:
|
|
if 1 <= num <= 16:
|
|
pattern.append('N')
|
|
elif 17 <= num <= 32:
|
|
pattern.append('M')
|
|
else:
|
|
pattern.append('H')
|
|
return ''.join(pattern)
|
|
|
|
def _calculate_trend_score(self, sequence):
|
|
"""Trend-Score Berechnung."""
|
|
if len(sequence) < 2:
|
|
return 0
|
|
x = np.arange(len(sequence))
|
|
y = np.array(sequence)
|
|
weights = np.exp(x / len(x))
|
|
try:
|
|
coeffs = np.polyfit(x, y, 1, w=weights)
|
|
return coeffs[0]
|
|
except:
|
|
return 0
|
|
|
|
def _calculate_recency_score(self, sequence):
|
|
"""Recency-Score Berechnung."""
|
|
try:
|
|
last_hit_index = len(sequence) - 1 - sequence[::-1].index(1)
|
|
recency = 1 - (len(sequence) - 1 - last_hit_index) / len(sequence)
|
|
return recency
|
|
except ValueError:
|
|
return 0
|
|
|
|
def _get_momentum_status(self, score):
|
|
"""Momentum-Status."""
|
|
if score > 0.5:
|
|
return "🔥 ULTRA-HEISS"
|
|
elif score > 0.35:
|
|
return "🌡️ SEHR HEISS"
|
|
elif score > 0.25:
|
|
return "😐 HEISS"
|
|
elif score > 0.15:
|
|
return "🧊 WARM"
|
|
else:
|
|
return "❄️ KALT"
|
|
|
|
# Zusätzliche Super-Funktionen für erweiterte Analyse
|
|
|
|
def analyze_winning_probability(generator, tip_numbers):
|
|
"""Analysiert Gewinnwahrscheinlichkeit basierend auf Super-Intelligence."""
|
|
base_prob = 1 / 13983816
|
|
|
|
# Super-Faktoren
|
|
factors = {
|
|
'unused_combination': 1.0,
|
|
'momentum_boost': 1.0,
|
|
'pattern_boost': 1.0,
|
|
'sequential_boost': 1.0
|
|
}
|
|
|
|
# Check ob nie gezogene Kombination
|
|
combo_tuple = tuple(sorted(tip_numbers))
|
|
for i in range(min(50000, len(generator.unused_combinations_sample))):
|
|
row = generator.unused_combinations_sample.iloc[i]
|
|
if combo_tuple == tuple(sorted([row['Z1'], row['Z2'], row['Z3'], row['Z4'], row['Z5'], row['Z6']])):
|
|
factors['unused_combination'] = 1.5 # 50% Boost für nie gezogene Kombination
|
|
break
|
|
|
|
# Momentum-Boost
|
|
hot_count = sum(1 for n in tip_numbers if n in generator.hot_numbers)
|
|
momentum_avg = np.mean([generator.momentum_scores[n]['momentum_score'] for n in tip_numbers])
|
|
factors['momentum_boost'] = 1 + (hot_count * 0.1) + (momentum_avg * 0.3)
|
|
|
|
# Pattern-Boost
|
|
pattern = generator._get_pattern(sorted(tip_numbers))
|
|
if pattern in generator.unused_patterns:
|
|
unused_pattern_freq = generator.unused_patterns[pattern] / len(generator.unused_combinations_sample)
|
|
factors['pattern_boost'] = 1 + (unused_pattern_freq * 0.2)
|
|
|
|
# Sequential-Boost (vereinfacht)
|
|
sequential_score = 0
|
|
for i in range(len(tip_numbers)-1):
|
|
transition_key = f"{tip_numbers[i]}_{tip_numbers[i+1]}"
|
|
for lag_data in generator.sequential_dependencies.values():
|
|
if transition_key in lag_data:
|
|
sequential_score += lag_data[transition_key]
|
|
|
|
if sequential_score > 0:
|
|
factors['sequential_boost'] = 1 + (sequential_score / 1000) # Normalisiert
|
|
|
|
# Gesamt-Multiplikator
|
|
total_multiplier = 1
|
|
for factor_value in factors.values():
|
|
total_multiplier *= factor_value
|
|
|
|
estimated_prob = base_prob * total_multiplier
|
|
|
|
return {
|
|
'base_probability': base_prob,
|
|
'factors': factors,
|
|
'total_multiplier': total_multiplier,
|
|
'estimated_probability': estimated_prob,
|
|
'improvement_factor': total_multiplier
|
|
}
|
|
|
|
def generate_super_analysis_report(generator, tips):
|
|
"""Generiert detaillierten Super-Analyse-Report."""
|
|
report = []
|
|
|
|
report.append("🚀 SUPER-LOTTO 6AUS49 ANALYSE-REPORT")
|
|
report.append("=" * 50)
|
|
report.append(f"📊 Basierend auf Sebastian's kompletter Datenbasis")
|
|
report.append(f"📈 {len(generator.df_historical):,} historische Ziehungen")
|
|
report.append(f"🎲 {len(generator.df_unused):,} nie gezogene Kombinationen")
|
|
report.append("")
|
|
|
|
# Tip-by-Tip Analyse
|
|
report.append("📋 DETAILLIERTE TIPP-ANALYSE:")
|
|
report.append("-" * 40)
|
|
|
|
for tip in tips:
|
|
report.append(f"\n🎯 TIPP {tip['tipp_nr']}:")
|
|
zahlen_str = f"{tip['z1']:2}-{tip['z2']:2}-{tip['z3']:2}-{tip['z4']:2}-{tip['z5']:2}-{tip['z6']:2}"
|
|
report.append(f" Zahlen: {zahlen_str} + SZ: {tip['superzahl']}")
|
|
report.append(f" 🔥 Heiße Zahlen: {tip['hot_count']}/6")
|
|
report.append(f" 📊 Momentum-Score: {tip['momentum_avg']:.3f}")
|
|
report.append(f" 🎯 Nie gezogen: {'✅ JA' if tip['unused_hit'] else '❌ NEIN'}")
|
|
report.append(f" 🎨 Muster: {tip['pattern']}")
|
|
|
|
# Wahrscheinlichkeits-Analyse
|
|
prob_analysis = analyze_winning_probability(generator, tip['zahlen'])
|
|
report.append(f" 📈 Verbesserungs-Faktor: {prob_analysis['improvement_factor']:.2f}x")
|
|
|
|
# Individuelle Zahlen-Analyse
|
|
report.append(" 🔍 Zahlen-Details:")
|
|
for num in tip['zahlen']:
|
|
momentum_data = generator.momentum_scores[num]
|
|
freq = generator.number_frequencies[num]
|
|
report.append(f" Zahl {num:2}: {momentum_data['status']} "
|
|
f"(Score: {momentum_data['momentum_score']:.3f}, {freq}x gezogen)")
|
|
|
|
# Super-Intelligence Zusammenfassung
|
|
report.append(f"\n🧠 SUPER-INTELLIGENCE ZUSAMMENFASSUNG:")
|
|
report.append("=" * 45)
|
|
|
|
# Nie gezogene Kombinationen Statistik
|
|
unused_hits = sum(1 for tip in tips if tip['unused_hit'])
|
|
report.append(f"🎯 {unused_hits}/{len(tips)} Tipps aus nie gezogenen Kombinationen")
|
|
|
|
# Momentum-Statistiken
|
|
avg_hot_numbers = sum(tip['hot_count'] for tip in tips) / len(tips)
|
|
avg_momentum = sum(tip['momentum_avg'] for tip in tips) / len(tips)
|
|
report.append(f"🔥 Ø {avg_hot_numbers:.1f} heiße Zahlen pro Tipp")
|
|
report.append(f"📊 Ø Momentum-Score: {avg_momentum:.3f}")
|
|
|
|
# Top Empfehlungen
|
|
report.append(f"\n💡 TOP EMPFEHLUNGEN:")
|
|
report.append(f"✅ Verwenden Sie die Tipps mit nie gezogenen Kombinationen")
|
|
report.append(f"🔥 Fokussieren Sie sich auf die {len(generator.hot_numbers)} heißesten Zahlen")
|
|
report.append(f"📈 Super-Momentum-Analyse zeigt beste Trends")
|
|
report.append(f"🎲 {len(generator.df_unused):,} nie gezogene Kombinationen = riesiger Vorteil!")
|
|
|
|
return "\n".join(report)
|
|
|
|
def export_comprehensive_analysis(generator, tips):
|
|
"""Exportiert umfassende Analyse in Text-Datei."""
|
|
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
report_file = f"{generator.base_path}/super_lotto_analysis_{timestamp}.txt"
|
|
|
|
report = generate_super_analysis_report(generator, tips)
|
|
|
|
with open(report_file, 'w', encoding='utf-8') as f:
|
|
f.write(report)
|
|
|
|
print(f"📄 Umfassende Analyse gespeichert: super_lotto_analysis_{timestamp}.txt")
|
|
|
|
def main():
|
|
"""Hauptfunktion für Super-Lotto Generator."""
|
|
print("🎲 SUPER-LOTTO 6AUS49 GENERATOR")
|
|
print("🚀 Mit Sebastian's kompletter Datenbasis")
|
|
print("=" * 50)
|
|
|
|
try:
|
|
# Generator mit Sebastian's Daten initialisieren
|
|
generator = SuperLotto6aus49Generator()
|
|
|
|
# Super-Tipps generieren
|
|
tips = generator.generate_super_tips(10)
|
|
|
|
if tips:
|
|
print(f"\n🏆 SUPER-OPTIMIERUNG ABGESCHLOSSEN!")
|
|
print("=" * 45)
|
|
print(f"🎲 10 Super-Tipps mit maximaler Intelligence generiert")
|
|
print(f"📊 Nutzt {len(generator.df_historical):,} historische Ziehungen")
|
|
print(f"🎯 Optimiert mit {len(generator.df_unused):,} nie gezogenen Kombinationen")
|
|
print(f"🔥 Multi-Momentum-Analyse mit Beschleunigung")
|
|
print(f"🧠 Sequential Dependencies Intelligence")
|
|
print(f"🍀 Maximale Gewinnchancen durch Super-Intelligence!")
|
|
|
|
# Erweiterte Analyse anbieten
|
|
print(f"\n📊 ERWEITERTE ANALYSE:")
|
|
print("=" * 30)
|
|
|
|
# Beispiel Super-Analyse
|
|
if len(tips) > 0:
|
|
sample_tip = tips[0]
|
|
prob_analysis = analyze_winning_probability(generator, sample_tip['zahlen'])
|
|
|
|
print(f"\n🔍 SUPER-ANALYSE für Tipp 1:")
|
|
zahlen_str = f"{sample_tip['z1']:2}-{sample_tip['z2']:2}-{sample_tip['z3']:2}-{sample_tip['z4']:2}-{sample_tip['z5']:2}-{sample_tip['z6']:2}"
|
|
print(f" 🎲 Super-Kombination: {zahlen_str} + SZ: {sample_tip['superzahl']}")
|
|
print(f" 🔥 Heiße Zahlen: {sample_tip['hot_count']}/6")
|
|
print(f" 📊 Momentum-Score: {sample_tip['momentum_avg']:.3f}")
|
|
print(f" 🎯 Nie gezogen: {'✅ JA' if sample_tip['unused_hit'] else '❌ NEIN'}")
|
|
print(f" 📈 Verbesserungs-Faktor: {prob_analysis['improvement_factor']:.2f}x")
|
|
print(f" 💎 Super-Score: {sample_tip['super_score']:.3f}")
|
|
|
|
# Angebot für vollständigen Report
|
|
create_report = input("\nVollständigen Analyse-Report erstellen? (j/n): ").lower().strip()
|
|
if create_report == 'j' or create_report == 'ja':
|
|
export_comprehensive_analysis(generator, tips)
|
|
print("✅ Vollständiger Report erstellt!")
|
|
|
|
print(f"\n🎯 SUPER-EMPFEHLUNGEN:")
|
|
print("=" * 30)
|
|
unused_count = sum(1 for tip in tips if tip['unused_hit'])
|
|
print(f"🎲 {unused_count} Tipps stammen aus nie gezogenen Kombinationen")
|
|
print(f"🔥 Alle Tipps nutzen Super-Momentum-Analyse")
|
|
print(f"📊 Basiert auf kompletter historischer Datenbasis")
|
|
print(f"💡 Maximale Optimierung durch Sebastian's Daten!")
|
|
|
|
else:
|
|
print("❌ Keine Super-Tipps generiert!")
|
|
|
|
except Exception as e:
|
|
print(f"❌ Fehler: {e}")
|
|
print("💡 Stellen Sie sicher, dass Sebastian's CSV-Dateien verfügbar sind:")
|
|
print(" 📁 AlleLottozahlen.csv")
|
|
print(" 📁 Fehlende_Lotto_Kombinationen.csv")
|
|
|
|
if __name__ == "__main__":
|
|
# Reproduzierbarer Seed
|
|
random.seed(42)
|
|
np.random.seed(42)
|
|
|
|
# Super-Generator starten
|
|
main() |