Create app.py

app.py

@@ -0,0 +1,128 @@
+import joblib
+import pandas as pd
+import numpy as np
+import gradio as gr
+
+# Carregar os modelos
+model_LayAway = joblib.load('model_class_layaway_0.pkl')
+model_LayAway_calibrated = joblib.load('platt_scaled_model_class_layaway_0.pkl')
+model_LayHome = joblib.load('model_class_layhome_1.pkl')
+
+# Faixas de precisão
+precision_by_bin = {
+    '0-5%': 0.592715,
+    '5-10%': 0.519316,
+    '10-15%': 0.524543,
+    '15-20%': 0.636364,
+    '20-25%': 0.666905,
+    '25-30%': 0.678614,
+    '30-35%': 0.694686,
+    '35-40%': 0.727428,
+    '40-45%': 0.732558,
+    '45-50%': 0.750000,
+    '50-55%': 0.784753,
+    '55-60%': 0.788012,
+    '60-65%': 0.786517,
+    '65-70%': 0.793349,
+    '70-75%': 0.818182,
+    '75-80%': 0.853535,
+    '80-85%': 0.822222,
+    '85-90%': 0.841962,
+    '90-95%': 0.853618,
+    '95-100%': 0.902997
+}
+
+def converter_para_float(valor):
+    return float(valor.replace(',', '.'))
+
+def calcular_percentual_recomendado(probabilidade, max_percent, min_percent, precision):
+    b = 1  # Supondo odds justas
+    p = probabilidade / 100
+    q = 1 - p
+    f_star = (b * p - q) / b
+    f_star = max(min(f_star, max_percent / 100), min_percent / 100)
+    if f_star < min_percent / 100:
+        f_star = min_percent / 100
+    return round(f_star * 100, 2)
+
+def determinar_faixa(probabilidade):
+    bins = [
+        '0-5%', '5-10%', '10-15%', '15-20%', '20-25%',
+        '25-30%', '30-35%', '35-40%', '40-45%', '45-50%',
+        '50-55%', '55-60%', '60-65%', '65-70%', '70-75%',
+        '75-80%', '80-85%', '85-90%', '90-95%', '95-100%'
+    ]
+    bin_width = 5
+    for b in bins:
+        lower, upper = map(int, b.split('-'))
+        if lower <= probabilidade < upper:
+            return b
+    return '95-100%'
+
+def fazer_previsao(ODD_H, ODD_D, ODD_A, min_percent, max_percent):
+    ODD_H = converter_para_float(ODD_H)
+    ODD_D = converter_para_float(ODD_D)
+    ODD_A = converter_para_float(ODD_A)
+
+    data = pd.DataFrame(
+        {'H/A': [ODD_H / ODD_A], 'Diff': [(ODD_H / ODD_D) - (ODD_H / ODD_A)]})
+    
+    previsao_LayAway = model_LayAway.predict(data)[0]
+    previsao_LayHome = model_LayHome.predict(data)[0]
+
+    if previsao_LayAway == previsao_LayHome:
+        resultado = 'Não entre!'
+    else:
+        if previsao_LayAway == 1:
+            entrada_LayAway = 'SIM'
+        else:
+            entrada_LayAway = 'NAO'
+
+        probabilidade_LayAway = round(
+            100 * model_LayAway.predict_proba(data)[0][1], 2)
+        probabilidade_LayAway_calibrated = round(
+            100 * model_LayAway_calibrated.predict_proba(probabilidade_LayAway.reshape(-1, 1))[0][1], 2)
+        probabilidade_LayHome = round(
+            100 * model_LayHome.predict_proba(data)[0][1], 2)
+        
+        # Determinar faixa de probabilidade e precisão correspondente
+        faixa = determinar_faixa(probabilidade_LayAway_calibrated)
+        precision = precision_by_bin[faixa]
+
+        # Calcular percentual recomendado e odds mínima
+        percentual_recomendado = calcular_percentual_recomendado(
+            probabilidade_LayAway_calibrated, max_percent, min_percent, precision
+        )
+        odds_minima = round(1 / precision, 2)
+
+        resultado = f"entrada LayAway (se Odd> 1.17): {entrada_LayAway}\n" \
+                    f"---> probabilidade: {probabilidade_LayAway}%\n" \
+                    f"---> probabilidade calibrada: {probabilidade_LayAway_calibrated}%\n" \
+                    f"---> Percentual recomendado da banca: {percentual_recomendado}%\n" \
+                    f"---> Odds mínima necessária: {odds_minima}\n" \
+                    f"\n" \
+                    f"entrada Home: {'SIM' if probabilidade_LayAway > 68.2 else 'NAO'}\n" \
+                    f"obs: Muito risco, apenas 67% de acerto (odds>1.489)\n" \
+                    f"\n" \
+                    f"entrada LayHome (se Odd> 1.28): {'SIM' if previsao_LayHome == 1 else 'NAO'}\n" \
+                    f"---> probabilidade: {probabilidade_LayHome}%\n" \
+                    f"---> Percentual recomendado da banca: {percentual_recomendado}%\n"
+
+    return resultado
+
+# Criar a interface Gradio
+iface = gr.Interface(
+    fn=fazer_previsao,
+    inputs=[
+        gr.Textbox(label="Odds para CASA vencer"),
+        gr.Textbox(label="Odds para EMPATE"),
+        gr.Textbox(label="Odds para VISITANTE vencer"),
+        gr.Slider(1, 40, label="Percentual Mínimo da Banca (%)", value=1),  # Slider mínimo com valor inicial 1
+        gr.Slider(10, 100, label="Percentual Máximo da Banca (%)", value=100)  # Slider máximo com valor inicial 100
+    ],
+    outputs="text",
+    title="Redução de Risco em Apostas",
+    description="Insira as Odds e obtenha uma sugestão para entradas LayAway (CASA vence ou EMPATA) e LayHome (VISITANTE vence ou EMPATA), juntamente com o percentual recomendado da banca e odds mínima."
+)
+
+iface.launch()