Spaces:
Runtime error
Runtime error
| 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 = pd.DataFrame({ | |
| 'Faixa': [ | |
| '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%' | |
| ], | |
| 'Precision': [ | |
| 0.592715, 0.519316, 0.524543, 0.636364, 0.666905, 0.678614, 0.694686, | |
| 0.727428, 0.732558, 0.750000, 0.784753, 0.788012, 0.786517, 0.793349, | |
| 0.818182, 0.853535, 0.822222, 0.841962, 0.853618, 0.902997 | |
| ] | |
| }) | |
| # Calcular odds_minima | |
| precision_by_bin['odds_minima'] = round(1 / precision_by_bin['Precision'],3) | |
| # Filtrar apenas faixas com >= 50% | |
| precision_filtered = precision_by_bin[precision_by_bin['Faixa'].str.contains('50-') | | |
| precision_by_bin['Faixa'].str.contains('60-') | | |
| precision_by_bin['Faixa'].str.contains('70-') | | |
| precision_by_bin['Faixa'].str.contains('80-') | | |
| precision_by_bin['Faixa'].str.contains('90-') | | |
| precision_by_bin['Faixa'].str.contains('95-100%')] | |
| 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 = np.arange(0, 1.05, 0.05) # Faixas de 0% a 100% com passos de 5% | |
| labels = precision_by_bin['Faixa'].tolist() | |
| # Encontrar o índice da faixa correspondente | |
| bin_index = np.digitize([probabilidade / 100], bins, right=False) - 1 | |
| # Corrigir para caso onde a probabilidade esteja exatamente no limite superior | |
| if bin_index[0] == len(labels): | |
| return labels[-1] # Retorna '95-100%' se estiver no limite máximo | |
| return labels[bin_index[0]] | |
| 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] | |
| 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) | |
| if previsao_LayAway == previsao_LayHome: | |
| resultado = f"Não entre! (Probabilidade LayAway: {probabilidade_LayAway_calibrated}%, Probabilidade LayHome: {probabilidade_LayHome}%)" | |
| else: | |
| if previsao_LayAway == 1: | |
| entrada_LayAway = 'SIM' | |
| else: | |
| entrada_LayAway = 'NAO' | |
| # Determinar faixa de probabilidade e precisão correspondente | |
| faixa = determinar_faixa(probabilidade_LayAway_calibrated) | |
| precision = precision_by_bin.loc[precision_by_bin['Faixa'] == faixa, 'Precision'].values[0] | |
| # 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, precision_filtered | |
| # 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=[ | |
| gr.Textbox(label="Recomendação"), | |
| gr.Dataframe(label="Tabela de Precision por Faixa >= 50%", value=precision_filtered) | |
| ], | |
| 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(share=True) | |