import gradio as gr
import numpy as np
import pandas as pd
from datetime import datetime
import random
from collections import defaultdict
import math
import traceback
# ==================== কনফিগারেশন ====================
CONFIG = {
"HISTORY_LIMIT": 1000,
"SEQUENCE_LENGTH": 12,
"PATTERN_DEPTH": 6,
"PINK_THRESHOLD": 3.0,
"BIG_PINK_THRESHOLD": 5.0,
"CONFIDENCE_THRESHOLD": 0.65,
"ENSEMBLE_WEIGHTS": {
"neuralNetwork": 0.35,
"sequencePattern": 0.30,
"markovChain": 0.20,
"statisticalModel": 0.15
}
}
# টাইম উইন্ডো কনফিগারেশন (পিঙ্ক জোন)
TIME_WINDOWS = [
{"start": 55, "end": 57, "name": "প্রাইম পিঙ্ক", "multiplier": 1.9, "probability": 0.90},
{"start": 59, "end": 1, "name": "প্রাইম পিঙ্ক", "multiplier": 1.9, "probability": 0.90},
{"start": 18, "end": 20, "name": "পিঙ্ক জোন", "multiplier": 1.4, "probability": 0.70},
{"start": 27, "end": 29, "name": "পিঙ্ক জোন", "multiplier": 1.4, "probability": 0.70},
{"start": 38, "end": 40, "name": "পিঙ্ক জোন", "multiplier": 1.4, "probability": 0.70},
{"start": 43, "end": 45, "name": "পিঙ্ক জোন", "multiplier": 1.4, "probability": 0.70},
{"start": 48, "end": 50, "name": "পিঙ্ক জোন", "multiplier": 1.4, "probability": 0.70},
]
# ==================== এমএল মডেল ক্লাস ====================
class NeuralNetwork:
"""নিউরাল নেটওয়ার্ক - প্যাটার্ন রিকগনিশনের জন্য"""
def __init__(self):
self.weights = {
'input': np.random.randn(15) * 0.1,
'hidden': np.random.randn(10) * 0.1,
'output': np.random.randn(5) * 0.1
}
self.performance_history = []
def extract_features(self, history):
"""ডাটা থেকে ফিচার এক্সট্র্যাক্ট করে"""
recent = history[:12]
features = []
# 1. সাম্প্রতিক ভ্যালু (লগ স্কেলে)
for val in recent:
features.append(math.log(val + 0.1) / math.log(10))
# 2. পরিসংখ্যানিক ফিচার
mean_val = np.mean(recent) if recent else 1.5
std_val = np.std(recent) if recent else 0.2
features.append(mean_val)
features.append(std_val / (mean_val + 0.1)) # কোএফিশিয়েন্ট অফ ভেরিয়েশন
# 3. ট্রেন্ড
if len(recent) >= 3:
trend = (recent[0] - recent[-1]) / len(recent)
features.append(trend)
else:
features.append(0)
# 4. পিঙ্ক রেশিও
pink_count = sum(1 for v in recent if v >= CONFIG["PINK_THRESHOLD"])
features.append(pink_count / len(recent) if recent else 0)
# প্যাডিং যদি কম হয়
while len(features) < 15:
features.append(0)
return np.array(features[:15]) # ম্যাক্স ১৫টি ফিচার
def predict(self, history):
"""প্রেডিকশন করে"""
try:
if len(history) < 5:
return {'prediction': 1.5, 'confidence': 0.3, 'analysis': 'পর্যাপ্ত ডাটা নেই', 'raw_value': 0}
features = self.extract_features(history)
# সিম্পল নিউরাল নেটওয়ার্ক ফরওয়ার্ড পাস
hidden = np.tanh(np.dot(features, self.weights['input'][:len(features)]))
output = np.tanh(hidden * np.mean(self.weights['hidden']))
# প্রেডিকশন ক্যালকুলেশন
prediction = 1.5 + (output * 3.0)
prediction = max(1.05, min(15.0, prediction))
# কনফিডেন্স ক্যালকুলেশন
confidence = min(0.9, 0.5 + (len(history) / 200) + abs(output) * 0.2)
analysis = self.generate_analysis(features, output)
return {
'prediction': float(prediction),
'confidence': float(confidence),
'analysis': analysis,
'raw_value': float(output)
}
except Exception as e:
print(f"NeuralNetwork error: {e}")
return {'prediction': 1.5, 'confidence': 0.3, 'analysis': 'এরর হয়েছে', 'raw_value': 0}
def generate_analysis(self, features, output):
"""অ্যানালাইসিস জেনারেট করে"""
if output > 0.6:
return "🧠 শক্তিশালী নিউরাল সিগন্যাল"
elif output < -0.4:
return "🧠 দুর্বল নিউরাল সিগন্যাল"
else:
return "🧠 নিউট্রাল নিউরাল প্যাটার্ন"
class SequenceAnalyzer:
"""সিকোয়েন্স অ্যানালাইজার - প্যাটার্ন খুঁজে বের করে"""
def __init__(self):
self.patterns = defaultdict(list)
self.max_pattern_length = CONFIG["PATTERN_DEPTH"]
def find_patterns(self, history):
"""ইতিহাসে প্যাটার্ন খুঁজে বের করে"""
patterns = []
for length in range(2, min(self.max_pattern_length, len(history) // 2)):
for i in range(len(history) - length * 2):
pattern = history[i:i+length]
next_seq = history[i+length:i+length*2]
similarity = self.calculate_similarity(pattern, next_seq)
if similarity > 0.6:
patterns.append({
'pattern': pattern,
'next': next_seq,
'similarity': similarity,
'length': length
})
return patterns
def calculate_similarity(self, seq1, seq2):
"""দুটি সিকোয়েন্সের মিল ক্যালকুলেট করে"""
if len(seq1) != len(seq2) or len(seq1) == 0:
return 0
diffs = [abs(seq1[i] - seq2[i]) / (max(seq1[i], seq2[i]) + 0.1)
for i in range(len(seq1))]
avg_diff = np.mean(diffs) if diffs else 1
return max(0, 1 - avg_diff)
def predict(self, history):
"""প্যাটার্ন-ভিত্তিক প্রেডিকশন"""
try:
if len(history) < 4:
return {'prediction': 1.5, 'confidence': 0.3, 'analysis': 'পর্যাপ্ত প্যাটার্ন নেই'}
patterns = self.find_patterns(history)
if not patterns:
return {
'prediction': 1.5,
'confidence': 0.4,
'analysis': '🔗 কোন প্যাটার্ন মেলেনি'
}
# সেরা প্যাটার্ন নির্বাচন
best_pattern = max(patterns, key=lambda p: p['similarity'] * p['length'])
# প্যাটার্ন থেকে প্রেডিকশন
trend = (best_pattern['pattern'][-1] - best_pattern['pattern'][0]) / len(best_pattern['pattern'])
prediction = best_pattern['pattern'][-1] + trend
# অ্যাডজাস্টমেন্ট
prediction = max(1.05, min(12.0, prediction))
confidence = best_pattern['similarity'] * 0.8
analysis = f"🔗 {best_pattern['length']}-দৈর্ঘ্যের প্যাটার্ন ({int(best_pattern['similarity']*100)}% মিল)"
return {
'prediction': float(prediction),
'confidence': float(confidence),
'analysis': analysis
}
except Exception as e:
print(f"SequenceAnalyzer error: {e}")
return {'prediction': 1.5, 'confidence': 0.3, 'analysis': 'প্যাটার্ন অ্যানালাইসিস এরর'}
class MarkovChain:
"""মার্কভ চেইন - স্টেট ট্রানজিশন প্রেডিক্ট করে"""
def __init__(self):
self.transition_matrix = defaultdict(lambda: defaultdict(float))
self.states = ['খুব_ছোট', 'ছোট', 'মাঝারি', 'বড়', 'পিঙ্ক']
def discretize(self, value):
"""ভ্যালুকে স্টেটে রূপান্তর করে"""
if value < 1.3:
return 'খুব_ছোট'
elif value < 1.8:
return 'ছোট'
elif value < 2.5:
return 'মাঝারি'
elif value < CONFIG["PINK_THRESHOLD"]:
return 'বড়'
else:
return 'পিঙ্ক'
def build_model(self, history):
"""ট্রানজিশন ম্যাট্রিক্স বিল্ড করে"""
self.transition_matrix.clear()
for i in range(len(history) - 1):
current = self.discretize(history[i])
next_state = self.discretize(history[i + 1])
self.transition_matrix[current][next_state] += 1
# নরমালাইজেশন
for state in self.transition_matrix:
total = sum(self.transition_matrix[state].values())
if total > 0:
for next_state in self.transition_matrix[state]:
self.transition_matrix[state][next_state] /= total
def predict(self, history):
"""মার্কভ চেইন থেকে প্রেডিকশন"""
try:
if len(history) < 2:
return {'prediction': 1.5, 'confidence': 0.3, 'analysis': 'পর্যাপ্ত ডাটা নেই'}
self.build_model(history)
current_state = self.discretize(history[0])
next_state_probs = self.transition_matrix.get(current_state, {})
if not next_state_probs:
# ডিফল্ট প্রোবাবিলিটি
next_state_probs = {
'খুব_ছোট': 0.2,
'ছোট': 0.4,
'মাঝারি': 0.25,
'বড়': 0.1,
'পিঙ্ক': 0.05
}
# স্টেট ভ্যালু ম্যাপিং
state_values = {
'খুব_ছোট': 1.15,
'ছোট': 1.5,
'মাঝারি': 2.2,
'বড়': 2.8,
'পিঙ্ক': 4.5
}
# ওয়েটেড এভারেজ
prediction = 0
total_prob = 0
for s, prob in next_state_probs.items():
prediction += state_values.get(s, 1.5) * prob
total_prob += prob
if total_prob > 0:
prediction /= total_prob
else:
prediction = 1.5
confidence = max(next_state_probs.values()) * 0.9 if next_state_probs else 0.3
most_likely = max(next_state_probs.items(), key=lambda x: x[1])[0] if next_state_probs else 'ছোট'
analysis = f"⛓️ মার্কভ: {current_state} → {most_likely} ({int(max(next_state_probs.values())*100)}%)"
return {
'prediction': float(prediction),
'confidence': float(confidence),
'analysis': analysis
}
except Exception as e:
print(f"MarkovChain error: {e}")
return {'prediction': 1.5, 'confidence': 0.3, 'analysis': 'মার্কভ এরর'}
class StatisticalModel:
"""পরিসংখ্যানিক মডেল - গড়, মিডিয়ান, ট্রেন্ড"""
def predict(self, history):
"""পরিসংখ্যানিক প্রেডিকশন"""
try:
if len(history) < 3:
return {'prediction': 1.5, 'confidence': 0.3, 'analysis': 'পর্যাপ্ত ডাটা নেই'}
recent = history[:10]
# বিভিন্ন পরিসংখ্যানিক মাপক
mean_val = np.mean(recent) if recent else 1.5
median_val = np.median(recent) if recent else 1.5
std_val = np.std(recent) if recent else 0.2
# ট্রেন্ড
if len(recent) >= 3:
x = np.arange(len(recent))
z = np.polyfit(x, recent, 1)
trend = z[0]
else:
trend = 0
# প্রেডিকশন (মিডিয়ান + ট্রেন্ড)
prediction = median_val + trend * 2
# স্ট্যান্ডার্ড ডিভিয়েশন অনুযায়ী অ্যাডজাস্টমেন্ট
if std_val > 1.0:
prediction += random.uniform(-0.5, 0.5)
prediction = max(1.05, min(10.0, prediction))
# কনফিডেন্স
confidence = min(0.8, 0.5 + (len(history) / 200) - (std_val / 10))
# অ্যানালাইসিস
if abs(trend) > 0.2:
trend_text = "উর্ধ্বমুখী" if trend > 0 else "নিম্নমুখী"
analysis = f"📊 {trend_text} ট্রেন্ড, মিডিয়ান: {median_val:.2f}x"
else:
analysis = f"📊 স্থিতিশীল, গড়: {mean_val:.2f}x"
return {
'prediction': float(prediction),
'confidence': float(confidence),
'analysis': analysis
}
except Exception as e:
print(f"StatisticalModel error: {e}")
return {'prediction': 1.5, 'confidence': 0.3, 'analysis': 'স্ট্যাটিস্টিক্যাল এরর'}
class EnsemblePredictor:
"""এনসেম্বল মডেল - সব মডেলকে একত্রে ব্যবহার করে"""
def __init__(self):
self.models = {
'neuralNetwork': NeuralNetwork(),
'sequencePattern': SequenceAnalyzer(),
'markovChain': MarkovChain(),
'statisticalModel': StatisticalModel()
}
self.weights = CONFIG["ENSEMBLE_WEIGHTS"].copy()
self.pattern_memory = {}
self.performance = {'overall': []}
def predict(self, history):
"""এনসেম্বল প্রেডিকশন"""
try:
if len(history) < 5:
return self.get_default_prediction()
predictions = {}
total_weighted = 0
total_weight = 0
for name, model in self.models.items():
try:
pred = model.predict(history)
predictions[name] = pred
weight = self.weights.get(name, 0.2) * pred['confidence']
total_weighted += pred['prediction'] * weight
total_weight += weight
except Exception as e:
print(f"Error in {name}: {e}")
predictions[name] = {'prediction': 1.5, 'confidence': 0.3, 'analysis': 'এরর'}
# এনসেম্বল প্রেডিকশন
ensemble_pred = total_weighted / total_weight if total_weight > 0 else 1.5
# টাইম উইন্ডো এফেক্ট
time_window = self.get_current_time_window()
if time_window:
ensemble_pred *= time_window['multiplier']
ensemble_pred = min(15.0, ensemble_pred)
# কনফিডেন্স ক্যালকুলেশন
confidences = [p.get('confidence', 0.3) for p in predictions.values()]
avg_confidence = np.mean(confidences) if confidences else 0.3
# পিঙ্ক সম্ভাবনা
pink_prob = self.calculate_pink_probability(history, predictions, time_window)
is_pink_expected = pink_prob > 0.4
# প্রেডিকশন ইন্টারভ্যাল
interval = self.calculate_prediction_interval(predictions, ensemble_pred, avg_confidence)
# রিস্ক লেভেল
risk = self.calculate_risk(interval, avg_confidence)
# অ্যানালাইসিস জেনারেট
analysis = self.generate_analysis(predictions, time_window, is_pink_expected)
# মডেল ডিটেইলস স্ট্রিং ফরম্যাটে
model_details_str = self.format_model_details(predictions)
return {
'prediction': float(ensemble_pred),
'interval_lower': float(interval['lower']),
'interval_upper': float(interval['upper']),
'confidence': float(avg_confidence),
'risk': risk,
'is_pink_expected': is_pink_expected,
'pink_probability': float(pink_prob),
'analysis': analysis,
'model_details': model_details_str,
'time_window': time_window['name'] if time_window else None
}
except Exception as e:
print(f"EnsemblePredictor error: {e}")
return self.get_default_prediction()
def format_model_details(self, predictions):
"""মডেল ডিটেইলসকে স্ট্রিং ফরম্যাটে কনভার্ট করে"""
lines = []
for name, pred in predictions.items():
model_names = {
'neuralNetwork': '🧠 নিউরাল',
'sequencePattern': '🔗 সিকোয়েন্স',
'markovChain': '⛓️ মার্কভ',
'statisticalModel': '📊 স্ট্যাট'
}
display_name = model_names.get(name, name)
lines.append(f"{display_name}: {pred.get('prediction', 1.5):.2f}x (কনফি: {int(pred.get('confidence', 0)*100)}%) - {pred.get('analysis', '')[:30]}")
return "\n".join(lines)
def get_default_prediction(self):
"""ডিফল্ট প্রেডিকশন"""
return {
'prediction': 1.5,
'interval_lower': 1.3,
'interval_upper': 1.7,
'confidence': 0.3,
'risk': 'মাঝারি ⚖️',
'is_pink_expected': False,
'pink_probability': 0.1,
'analysis': '🧠 পর্যাপ্ত ডাটা নেই। কমপক্ষে ৫টি রাউন্ড প্রয়োজন।',
'model_details': 'কোন মডেল ডাটা নেই',
'time_window': None
}
def get_current_time_window(self):
"""বর্তমান টাইম উইন্ডো চেক করে"""
now = datetime.now()
minutes = now.minute
for window in TIME_WINDOWS:
if window['start'] <= window['end']:
if minutes >= window['start'] and minutes <= window['end']:
return window
else:
if minutes >= window['start'] or minutes <= window['end']:
return window
return None
def calculate_pink_probability(self, history, predictions, time_window):
"""পিঙ্ক হওয়ার সম্ভাবনা ক্যালকুলেট করে"""
factors = []
# টাইম উইন্ডো ফ্যাক্টর
if time_window:
factors.append(time_window['probability'])
# মডেল কনসেনসাস
if predictions:
pink_predictions = sum(1 for p in predictions.values()
if p.get('prediction', 1.5) >= CONFIG["PINK_THRESHOLD"])
factors.append(pink_predictions / len(predictions))
# হিস্টোরিক্যাল ফ্যাক্টর
if history:
recent_pinks = sum(1 for v in history[:20] if v >= CONFIG["PINK_THRESHOLD"])
factors.append(min(0.9, recent_pinks / 20))
return np.mean(factors) if factors else 0.2
def calculate_prediction_interval(self, predictions, center, confidence):
"""প্রেডিকশন ইন্টারভ্যাল ক্যালকুলেট করে"""
pred_values = [p.get('prediction', 1.5) for p in predictions.values()]
std = np.std(pred_values) if len(pred_values) > 1 else 0.2
spread = std * (2 - confidence)
spread = max(0.1, min(1.5, spread))
return {
'lower': max(1.01, center - spread/2),
'upper': center + spread/2
}
def calculate_risk(self, interval, confidence):
"""রিস্ক লেভেল ক্যালকুলেট করে"""
spread = interval['upper'] - interval['lower']
avg = (interval['lower'] + interval['upper']) / 2
relative_spread = spread / avg if avg > 0 else 0.5
if relative_spread < 0.2 and confidence > 0.7:
return "নিম্ন ✅"
elif relative_spread > 0.5 or confidence < 0.45:
return "উচ্চ ⚠️"
else:
return "মাঝারি ⚖️"
def generate_analysis(self, predictions, time_window, is_pink):
"""অ্যানালাইসিস টেক্সট জেনারেট করে"""
parts = []
# মডেল অ্যানালাইসিস
for name, pred in predictions.items():
if pred.get('confidence', 0) > 0.6:
parts.append(pred.get('analysis', ''))
# টাইম উইন্ডো
if time_window:
parts.append(f"⏰ {time_window['name']}")
# পিঙ্ক
if is_pink:
parts.append("🌸 পিঙ্ক সম্ভাবনা")
if not parts:
return "🧠 মডেল অ্যানালাইসিস চলছে..."
return " | ".join(parts[:3]) # সর্বোচ্চ ৩টি অংশ
# ==================== মেইন অ্যাপ্লিকেশন ====================
class AviatorPredictorApp:
"""মেইন অ্যাপ্লিকেশন ক্লাস"""
def __init__(self):
self.history = []
self.predictor = EnsemblePredictor()
self.last_prediction = None
def add_round(self, multiplier):
"""নতুন রাউন্ড যোগ করে"""
if multiplier <= 0:
return False
self.history.insert(0, float(multiplier))
if len(self.history) > CONFIG["HISTORY_LIMIT"]:
self.history = self.history[:CONFIG["HISTORY_LIMIT"]]
return True
def reset(self):
"""হিস্ট্রি রিসেট করে"""
self.history = []
self.last_prediction = None
# ২০টি র্যান্ডম রাউন্ড জেনারেট করে
for _ in range(20):
self.history.append(round(random.uniform(1.0, 3.5), 2))
self.history.sort(reverse=True)
def get_prediction(self):
"""বর্তমান প্রেডিকশন রিটার্ন করে"""
if len(self.history) < 3:
return self.predictor.get_default_prediction()
self.last_prediction = self.predictor.predict(self.history)
return self.last_prediction
def get_history_table(self):
"""হিস্ট্রি টেবিল রিটার্ন করে (শুধু ডাটা, কোন বুলিয়ান না)"""
return [[i+1, f"{val:.2f}x"] for i, val in enumerate(self.history[:50])]
def get_time_status(self):
"""টাইম স্ট্যাটাস রিটার্ন করে"""
now = datetime.now()
time_str = now.strftime("%H:%M:%S")
current = self.predictor.get_current_time_window()
if current:
status = f"🌸 {current['name']} একটিভ! 🌸"
detail = f"বুস্ট: +{int((current['multiplier']-1)*100)}% | {int(current['probability']*100)}% পিঙ্ক সম্ভাবনা"
css_class = "active-window"
else:
# পরবর্তী উইন্ডো খুঁজে বের করা
next_window = None
min_minutes = 60
for window in TIME_WINDOWS:
if window['start'] <= window['end']:
if now.minute < window['start']:
minutes = window['start'] - now.minute
else:
minutes = (60 - now.minute) + window['start']
else:
if now.minute >= window['start']:
minutes = (60 - now.minute) + window['end']
elif now.minute <= window['end']:
minutes = 0
else:
minutes = window['start'] - now.minute
if 0 < minutes < min_minutes:
min_minutes = minutes
next_window = window
if next_window and min_minutes <= 2:
status = f"⚠️ {next_window['name']} আসছে {min_minutes} মিনিটে"
detail = "প্রস্তুত হোন!"
css_class = "approaching-window"
else:
status = "পিঙ্ক জোনের অপেক্ষায়..."
detail = next_window and f"পরবর্তী: {next_window['name']} {min_minutes} মিনিটে" or "কোন উইন্ডো নেই"
css_class = "waiting-window"
return f"""
{time_str}
{status}
{detail}
"""
def get_confidence_html(self):
"""কনফিডেন্স বার এইচটিএমএল রিটার্ন করে"""
if not self.last_prediction:
conf = 0.3
is_pink = False
else:
conf = self.last_prediction.get('confidence', 0.3)
is_pink = self.last_prediction.get('is_pink_expected', False)
color_class = "pink-text" if is_pink else ""
pink_text = "🌸 পিঙ্ক মোড" if is_pink else ""
return f"""
এমএল কনফিডেন্স: {int(conf*100)}%
{pink_text}
"""
# ==================== কাস্টম সিএসএস ====================
CUSTOM_CSS = """
/* ডার্ক মোড বেস */
.gradio-container {
background: #0a0a0f !important;
color: #ffffff !important;
}
footer {visibility: hidden}
/* টাইম বক্স স্টাইল */
.time-box {
text-align: center;
padding: 15px;
border-radius: 10px;
margin-bottom: 20px;
transition: all 0.3s;
font-weight: 500;
}
.active-window {
background: linear-gradient(135deg, #ff1493, #ff69b4) !important;
color: white !important;
box-shadow: 0 0 20px #ff1493;
}
.approaching-window {
background: linear-gradient(135deg, #ffa726, #ff9800) !important;
color: white !important;
box-shadow: 0 0 20px #ffa726;
}
.waiting-window {
background: linear-gradient(135deg, #1a1a2e, #16213e) !important;
color: white !important;
border: 1px solid #00d4ff;
}
/* পিঙ্ক টেক্সট */
.pink-text {
color: #ff1493 !important;
font-weight: bold !important;
}
/* কনফিডেন্স বার */
.confidence-bar {
height: 8px;
background: #333;
border-radius: 4px;
overflow: hidden;
margin: 5px 0;
}
.confidence-fill {
height: 100%;
background: linear-gradient(90deg, #00d4ff, #ff1493);
transition: width 0.3s;
}
/* প্রেডিকশন ইন্টারভ্যাল */
.prediction-interval {
font-size: 32px;
font-weight: 700;
text-align: center;
margin: 10px 0;
padding: 15px;
background: rgba(255,255,255,0.05);
border-radius: 10px;
}
.prediction-interval.pink-mode {
color: #ff1493;
text-shadow: 0 0 10px #ff1493;
}
.interval-lower {
color: #00d4ff;
}
.interval-upper {
color: #ffa726;
}
.interval-separator {
color: white;
margin: 0 10px;
}
/* টেক্সটবক্স স্টাইল */
.gr-box {
border: 1px solid #333 !important;
background: rgba(255,255,255,0.05) !important;
}
.gr-box label {
color: #00d4ff !important;
}
/* বাটন স্টাইল */
.gr-button-primary {
background: linear-gradient(135deg, #00d4ff, #0088ff) !important;
border: none !important;
}
.gr-button-secondary {
background: rgba(255,255,255,0.1) !important;
border: 1px solid #00d4ff !important;
}
/* ডাটাফ্রেম */
.gr-dataframe {
background: rgba(255,255,255,0.05) !important;
}
"""
# ==================== গ্র্যাডিও ইন্টারফেস ====================
# অ্যাপ ইনিশিয়ালাইজ
app = AviatorPredictorApp()
app.reset() # শুরুতেই কিছু ডাটা জেনারেট করে
# গ্র্যাডিও ইন্টারফেস
with gr.Blocks(css=CUSTOM_CSS) as demo:
# হেডার
gr.HTML("""
✈️ AVOLD ML
এনসেম্বল এমএল এভিয়েটর প্রেডিক্টর v3.0
""")
# টাইম সেকশন
time_html = gr.HTML(value=app.get_time_status())
# ইনপুট রো
with gr.Row():
new_multiplier = gr.Number(
label="নতুন মাল্টিপ্লায়ার",
value=1.0,
step=0.1,
minimum=1.0,
maximum=100.0
)
add_btn = gr.Button("➕ যোগ করুন", variant="primary")
# রিসেট বাটন
reset_btn = gr.Button("🔄 রিসেট ডাটা", variant="secondary")
# প্রেডিকশন ডিসপ্লে
with gr.Row():
with gr.Column():
gr.Markdown("### 🎯 প্রেডিকশন ইন্টারভ্যাল")
prediction_html = gr.HTML()
# তিনটি আউটপুট এক লাইনে
with gr.Row():
expected_out = gr.Textbox(label="📊 এক্সপেক্টেড", interactive=False)
analysis_out = gr.Textbox(label="📈 অ্যানালাইসিস", interactive=False)
decision_out = gr.Textbox(label="🎯 ডিসিশন", interactive=False)
# কনফিডেন্স এবং রিস্ক
with gr.Row():
with gr.Column(scale=3):
confidence_html = gr.HTML(value=app.get_confidence_html())
with gr.Column(scale=1):
risk_out = gr.Textbox(label="রিস্ক লেভেল", interactive=False)
# পিঙ্ক প্রোবাবিলিটি
pink_prob_out = gr.Textbox(label="🌸 পিঙ্ক সম্ভাবনা", interactive=False)
# মডেল ডিটেইলস (টেক্সট বক্স হিসেবে - JSON এরর এড়াতে)
model_details = gr.Textbox(
label="🧠 মডেল ডিটেইলস",
interactive=False,
lines=5
)
# টেবিল
rounds_table = gr.Dataframe(
label="📜 শেষ ৫০ রাউন্ড",
headers=["রাউন্ড", "মাল্টিপ্লায়ার"],
row_count=10,
interactive=False
)
# ---------- আপডেট ফাংশন ----------
def update_all():
"""সব ডিসপ্লে আপডেট করে - শুধু ডাটা রিটার্ন করে, কোন বুলিয়ান না"""
try:
pred = app.get_prediction()
history_table = app.get_history_table()
time_status = app.get_time_status()
confidence = app.get_confidence_html()
# প্রেডিকশন এইচটিএমএল
pink_class = "pink-mode" if pred.get('is_pink_expected', False) else ""
prediction_html_str = f"""
{pred.get('interval_lower', 1.3):.2f}x
—
{pred.get('interval_upper', 1.7):.2f}x
"""
# ডিসিশন
if pred.get('is_pink_expected', False):
decision = "পিঙ্ক আশান্বিত 🌸"
elif pred.get('prediction', 1.5) > 3.0:
decision = "বড় মাল্টিপ্লায়ার 🚀"
elif pred.get('prediction', 1.5) > 1.8:
decision = "মাঝারি 💪"
else:
decision = "ছোট 🎯"
# পিঙ্ক প্রোবাবিলিটি টেক্সট
pink_prob_text = f"{int(pred.get('pink_probability', 0)*100)}%"
# মডেল ডিটেইলস
model_text = pred.get('model_details', 'কোন ডাটা নেই')
return [
history_table, # dataframe
time_status, # html
confidence, # html
prediction_html_str, # html
f"{pred.get('prediction', 1.5):.2f}x", # textbox
pred.get('analysis', 'অ্যানালাইসিস নেই'), # textbox
decision, # textbox
pred.get('risk', 'মাঝারি ⚖️'), # textbox
pink_prob_text, # textbox
model_text # textbox
]
except Exception as e:
print(f"Update error: {e}")
traceback.print_exc()
# এরর হলে ডিফল্ট ভ্যালু রিটার্ন
default_table = [[1, "1.00x"]]
default_time = ''
default_conf = 'এমএল কনফিডেন্স: 0%
'
default_pred = '1.30x—1.70x
'
return [
default_table,
default_time,
default_conf,
default_pred,
"1.50x",
"আপডেট এরর",
"ছোট 🎯",
"মাঝারি ⚖️",
"0%",
"মডেল লোড করতে সমস্যা হয়েছে"
]
# অ্যাড বাটন ক্লিক
add_btn.click(
fn=lambda x: (
app.add_round(x), # এইটা True রিটার্ন করে, কিন্তু আমরা ইউজ করছি না
*update_all() # শুধু আপডেট ডাটা রিটার্ন করছি
)[-10:], # শুধু শেষ ১০টি ভ্যালু নিচ্ছি (ডাটাফ্রেম থেকে শুরু)
inputs=[new_multiplier],
outputs=[rounds_table, time_html, confidence_html, prediction_html,
expected_out, analysis_out, decision_out, risk_out,
pink_prob_out, model_details]
)
# রিসেট বাটন ক্লিক
reset_btn.click(
fn=lambda: (
app.reset(),
*update_all()
)[-10:],
outputs=[rounds_table, time_html, confidence_html, prediction_html,
expected_out, analysis_out, decision_out, risk_out,
pink_prob_out, model_details]
)
# ইনিশিয়াল লোড
demo.load(
fn=update_all,
outputs=[rounds_table, time_html, confidence_html, prediction_html,
expected_out, analysis_out, decision_out, risk_out,
pink_prob_out, model_details]
)
# ==================== অ্যাপ রান ====================
if __name__ == "__main__":
demo.launch(
server_name="0.0.0.0",
server_port=7860,
share=False
)