Python - Addestramento rete neurale

druid · 9 Febbraio 2025

lottoandy81 ha scritto:
ciao a tutti qualcuno mi può aiutare come usare python siamo proprio alle basi

Ciao, se vai su youtube ci sono diversi corsi free che ti danno una buona infarinata....poi il resto e' tanta pratica....per quanto riguarda le reti neurali e' qualcosa di avanzato....si', certo l' IA da' una mano, ma solo se sai cosa significa il codice che vuoi scrivere, perche' il 90% delle volte non capisce cosa vogliamo realizzare.....

max63 · 11 Febbraio 2025

Buongiorno a tutti!

Lottopython se hai tempo e voglia puoi dare un occhiata a queste prove tecniche di trasmissione?

Grazie mille

Ciao a tutti!

max63 · 11 Febbraio 2025

Agevolato l'inserimento date e varie cose

Lottopython · 11 Febbraio 2025

max63 ha scritto:
Agevolato l'inserimento date e varie cose

davvero ben fatto , funzionale e intuitivo ,bravo complimenti

Lottopython · 11 Febbraio 2025

una chicca la selezione delle date.

max63 · 11 Febbraio 2025

Mi sto complicando un po' la vita....Appena finito pubblico se riesco a correggere due cose

batty · Giovedì alle 03:14

Buongiorno signori vi faccio i complimenti ,trovo molto interessante questo lavoro che state portando avanti , e vorrei divertirmi pure io ha fare qualche migliaio di prove strapazzando la rete neuro

ho installato python con tutte le librerie necessarie pure io smadonnando un pò e con l'aiuto della IA. poi mi sono fatto un giro avanti e indietro nei vari post, ma non ho trovato indicazioni al riguardo , la domanda è questa , per far girare il codiè gentilmente offerto da LottoPython (che ringrazio) mi servirebbe sapere come deve essere strutturato l'archivio da dare in pasto al programma e con quale nome e in quale cartella deve essere messo per far si che il programma lo trovi .io ho fatto uno script
che mi crea nella stessa cartella le 11 ruote esempio "BA.txt" ed i dati al loro interno sono strutturati in questo modo
"2025/02/08 78 32 43 68 85"
"2025/02/11 28 43 24 13 31" senza intestazione iniziale.

Ringrazio anticipatamente per un'eventuale risposta. Buona serata a tutti

Lottopython · Giovedì alle 09:13

batty ha scritto:
Buongiorno signori vi faccio i complimenti ,trovo molto interessante questo lavoro che state portando avanti , e vorrei divertirmi pure io ha fare qualche migliaio di prove strapazzando la rete neuro ho installato python con tutte le librerie necessarie pure io smadonnando un pò e con l'aiuto della IA. poi mi sono fatto un giro avanti e indietro nei vari post, ma non ho trovato indicazioni al riguardo , la domanda è questa , per far girare il codiè gentilmente offerto da LottoPython (che ringrazio) mi servirebbe sapere come deve essere strutturato l'archivio da dare in pasto al programma e con quale nome e in quale cartella deve essere messo per far si che il programma lo trovi .io ho fatto uno script
che mi crea nella stessa cartella le 11 ruote esempio "BA.txt" ed i dati al loro interno sono strutturati in questo modo
"2025/02/08 78 32 43 68 85"
"2025/02/11 28 43 24 13 31" senza intestazione iniziale.

Ringrazio anticipatamente per un'eventuale risposta. Buona serata a tutti

Ciao, è molto semplice, in questo piccolo script che ti allego :

1.genera file di testo vuoto es Bari.txt Cagliari.txt etc
2..una volta che inserisci le date ti aggiorna i file.

non dovresti ricevere piu l'errore

2025/02/01 NZ 19 89 28 18 33
2025/02/04 NZ 50 89 12 80 52
2025/02/06 NZ 81 37 26 1 7
2025/02/07 NZ 22 21 66 4 47
2025/02/08 NZ 87 5 13 6 69
2025/02/11 NZ 4 87 35 31 29

il codice dovrebbe anche risolvere il problema che riguardava la ruota NZ , che prima veniva richiamata RN

ti allego il codice che con il formato txt.zip potrebbe risultare errata l'identazione.

copi il codice in un file di testo , modifichi il tuo percorso ,lo rinomini e lo inserisci nella cartella Python

NB :RICORDA DI AGGIUNGERE IL TUO PERCORSO

percorso_estrazione = r'C:\TUOPERCORSO\Python\Python312'

Codice:

import tkinter as tk
from tkinter import messagebox
import os
import requests
import zipfile
import io

# Percorso di estrazione (e dove verranno creati i file .txt)
PERCORSO_ESTRAZIONE = r'C:\Users\PRODESC\AppData\Local\Programs\Python\Python312\Testcartelle'  # <---- MODIFICA QUI SE NECESSARIO

def scarica_e_estrai_zip(url, destinazione):
    try:
        response = requests.get(url)
        response.raise_for_status()  # Genera un'eccezione per codici di stato HTTP errati
        with zipfile.ZipFile(io.BytesIO(response.content)) as z:
            z.extractall(destinazione)
        return True
    except requests.exceptions.RequestException as e:
        messagebox.showerror("Errore", f"Errore durante il download: {e}")
        return False
    except zipfile.BadZipFile as e:
        messagebox.showerror("Errore", f"Errore nel file ZIP: {e}")
        return False
    except Exception as e:
        messagebox.showerror("Errore", f"Errore sconosciuto: {e}")
        return False

def carica_dati_da_file(nome_file):
    try:
        with open(nome_file, 'r') as file:
            return [line.strip() for line in file.readlines()]
    except FileNotFoundError:
        return []  # Restituisce una lista vuota se il file non esiste
    except Exception as e:
        messagebox.showerror("Errore", f"Errore durante la lettura del file {nome_file}: {e}")
        return []

def salva_dati_su_file(dati_ruote):
    for ruota, dati in dati_ruote.items():
        if dati:
            nome_file = os.path.join(PERCORSO_ESTRAZIONE, mappa_ruote[ruota]) # Percorso completo
            try:
                with open(nome_file, 'a') as file:
                    for line in dati:
                        # Formatta la linea per la ruota Nazionale (aggiunge tabulazioni)
                        if ruota == "NZ":
                            parts = line.split()
                            if len(parts) >= 7:  # Assicurati di avere abbastanza elementi
                                line = f"{parts[0]}\t{parts[1]}\t{parts[2]}\t{parts[3]}\t{parts[4]}\t{parts[5]}\t{parts[6]}"
                        file.write(line + '\n')
            except Exception as e:
                messagebox.showerror("Errore", f"Errore durante la scrittura nel file {nome_file}: {e}")

def aggiorna_file(data_inizio, data_fine, percorso_estrazione): # aggiunto percorso_estrazione
    global mappa_ruote
    mappa_ruote = {
        "BA": "Bari.txt",
        "CA": "Cagliari.txt",
        "FI": "Firenze.txt",
        "GE": "Genova.txt",
        "MI": "Milano.txt",
        "NA": "Napoli.txt",
        "PA": "Palermo.txt",
        "RM": "Roma.txt",
        "NZ": "Nazionale.txt",
        "TO": "Torino.txt",
        "VE": "Venezia.txt"
    }

    tutti_dati_filtrati = {ruota: [] for ruota in mappa_ruote.keys()}

    # Usa il percorso completo per caricare il file storico.txt
    storico_file_path = os.path.join(percorso_estrazione, 'storico.txt')
    dati = carica_dati_da_file(storico_file_path) # Usa il percorso completo

    for line in dati:
        parts = line.split()
        if len(parts) < 2:
            continue
        date = parts[0]
        ruota = parts[1]

        if data_inizio <= date <= data_fine:
            # Gestione della ruota Nazionale (RN -> NZ)
            if ruota == "RN":
                ruota = "NZ"
                parts[1] = "NZ"  # Modifica la ruota nella linea
                line = ' '.join(parts)  # Ricostruisci la linea con "NZ"

            if ruota in tutti_dati_filtrati:
                tutti_dati_filtrati[ruota].append(line)

    tutti_dati_filtrati = {ruota: lines for ruota, lines in tutti_dati_filtrati.items() if lines}

    if not tutti_dati_filtrati:
        messagebox.showinfo("Info", "Nessun dato trovato per le ruote specificate e le date.")
        return

    salva_dati_su_file(tutti_dati_filtrati)
    messagebox.showinfo("Successo", "Dati aggiornati per tutte le ruote.")

def aggiorna_tutti_file():
    # Specifica il percorso di estrazione
    # percorso_estrazione = r'C:\TUO PERCORSO \Python\Python312' # NON SERVE PIU', USA LA COSTANTE GLOBALE

    if scarica_e_estrai_zip("https://www.igt.it/STORICO_ESTRAZIONI_LOTTO/storico.zip", PERCORSO_ESTRAZIONE):
        # Correggi RN in NZ nel file storico.txt appena scaricato
        storico_file_path = os.path.join(PERCORSO_ESTRAZIONE, 'storico.txt') # Percorso completo
        try:
            with open(storico_file_path, 'r') as file:
                lines = file.readlines()

            with open(storico_file_path, 'w') as file:
                for line in lines:
                    file.write(line.replace(' RN ', ' NZ '))
        except Exception as e:
            messagebox.showerror("Errore", f"Errore durante la correzione RN -> NZ: {e}")
            return # Importante uscire in caso di errore

        if os.path.exists(storico_file_path):
            data_inizio = data_inizio_entry.get()
            data_fine = data_fine_entry.get()

            if not data_inizio:
                messagebox.showerror("Errore", "Inserisci una data di inizio.")
                return

            aggiorna_file(data_inizio, data_fine, PERCORSO_ESTRAZIONE) # Passa il percorso alla funzione
        else:
            messagebox.showerror("Errore", "Il file storico.txt non è stato trovato dopo l'estrazione.")
    else:
        messagebox.showerror("Errore", "Il download del file storico.zip è fallito.")

def crea_file():
    global mappa_ruote
    mappa_ruote = {
        "BA": "Bari.txt",
        "CA": "Cagliari.txt",
        "FI": "Firenze.txt",
        "GE": "Genova.txt",
        "MI": "Milano.txt",
        "NA": "Napoli.txt",
        "PA": "Palermo.txt",
        "RM": "Roma.txt",
        "NZ": "Nazionale.txt",
        "TO": "Torino.txt",
        "VE": "Venezia.txt"
    }
    for ruota in mappa_ruote:
        nome_file = os.path.join(PERCORSO_ESTRAZIONE, mappa_ruote[ruota]) # Percorso completo
        try:
            if not os.path.exists(nome_file):
                open(nome_file, 'w').close()  # Crea un file vuoto
                print(f"File {nome_file} creato in {PERCORSO_ESTRAZIONE}.")
        except Exception as e:
            messagebox.showerror("Errore", f"Errore durante la creazione del file {nome_file}: {e}")
            return # Esci dalla funzione in caso di errore
    messagebox.showinfo("Successo", "Tutti i file mancanti sono stati creati.")


# Creazione della finestra principale
root = tk.Tk()
root.title("Aggiornamento Dati Lotto")

data_inizio_var = tk.StringVar()
data_fine_var = tk.StringVar()

tk.Label(root, text="Data di Inizio (AAAA/MM/GG):").grid(row=0, column=0, padx=10, pady=10)
data_inizio_entry = tk.Entry(root, textvariable=data_inizio_var)
data_inizio_entry.grid(row=0, column=1, padx=10, pady=10)

tk.Label(root, text="Data di Fine (AAAA/MM/GG):").grid(row=1, column=0, padx=10, pady=10)
data_fine_entry = tk.Entry(root, textvariable=data_fine_var)
data_fine_entry.grid(row=1, column=1, padx=10, pady=10)

tk.Button(root, text="Aggiorna Tutti i File", command=aggiorna_tutti_file).grid(row=2, column=0, columnspan=2, padx=10, pady=10)
tk.Button(root, text="Crea File Mancanti", command=crea_file).grid(row=3, column=0, columnspan=2, padx=10, pady=10)

root.mainloop()

batty · Giovedì alle 11:25

Lottopython ha scritto:

Ciao, è molto semplice, in questo piccolo script che ti allego :

1.genera file di testo vuoto es Bari.txt Cagliari.txt etc
2..una volta che inserisci le date ti aggiorna i file.

non dovresti ricevere piu l'errore

2025/02/01 NZ 19 89 28 18 33
2025/02/04 NZ 50 89 12 80 52
2025/02/06 NZ 81 37 26 1 7
2025/02/07 NZ 22 21 66 4 47
2025/02/08 NZ 87 5 13 6 69
2025/02/11 NZ 4 87 35 31 29

il codice dovrebbe anche risolvere il problema che riguardava la ruota NZ , che prima veniva richiamata RN

ti allego il codice che con il formato txt.zip potrebbe risultare errata l'identazione.

copi il codice in un file di testo , modifichi il tuo percorso ,lo rinomini e lo inserisci nella cartella Python

NB :RICORDA DI AGGIUNGERE IL TUO PERCORSO

percorso_estrazione = r'C:\TUOPERCORSO\Python\Python312'

Codice:

import tkinter as tk
from tkinter import messagebox
import os
import requests
import zipfile
import io

# Percorso di estrazione (e dove verranno creati i file .txt)
PERCORSO_ESTRAZIONE = r'C:\Users\PRODESC\AppData\Local\Programs\Python\Python312\Testcartelle'  # <---- MODIFICA QUI SE NECESSARIO

def scarica_e_estrai_zip(url, destinazione):
    try:
        response = requests.get(url)
        response.raise_for_status()  # Genera un'eccezione per codici di stato HTTP errati
        with zipfile.ZipFile(io.BytesIO(response.content)) as z:
            z.extractall(destinazione)
        return True
    except requests.exceptions.RequestException as e:
        messagebox.showerror("Errore", f"Errore durante il download: {e}")
        return False
    except zipfile.BadZipFile as e:
        messagebox.showerror("Errore", f"Errore nel file ZIP: {e}")
        return False
    except Exception as e:
        messagebox.showerror("Errore", f"Errore sconosciuto: {e}")
        return False

def carica_dati_da_file(nome_file):
    try:
        with open(nome_file, 'r') as file:
            return [line.strip() for line in file.readlines()]
    except FileNotFoundError:
        return []  # Restituisce una lista vuota se il file non esiste
    except Exception as e:
        messagebox.showerror("Errore", f"Errore durante la lettura del file {nome_file}: {e}")
        return []

def salva_dati_su_file(dati_ruote):
    for ruota, dati in dati_ruote.items():
        if dati:
            nome_file = os.path.join(PERCORSO_ESTRAZIONE, mappa_ruote[ruota]) # Percorso completo
            try:
                with open(nome_file, 'a') as file:
                    for line in dati:
                        # Formatta la linea per la ruota Nazionale (aggiunge tabulazioni)
                        if ruota == "NZ":
                            parts = line.split()
                            if len(parts) >= 7:  # Assicurati di avere abbastanza elementi
                                line = f"{parts[0]}\t{parts[1]}\t{parts[2]}\t{parts[3]}\t{parts[4]}\t{parts[5]}\t{parts[6]}"
                        file.write(line + '\n')
            except Exception as e:
                messagebox.showerror("Errore", f"Errore durante la scrittura nel file {nome_file}: {e}")

def aggiorna_file(data_inizio, data_fine, percorso_estrazione): # aggiunto percorso_estrazione
    global mappa_ruote
    mappa_ruote = {
        "BA": "Bari.txt",
        "CA": "Cagliari.txt",
        "FI": "Firenze.txt",
        "GE": "Genova.txt",
        "MI": "Milano.txt",
        "NA": "Napoli.txt",
        "PA": "Palermo.txt",
        "RM": "Roma.txt",
        "NZ": "Nazionale.txt",
        "TO": "Torino.txt",
        "VE": "Venezia.txt"
    }

    tutti_dati_filtrati = {ruota: [] for ruota in mappa_ruote.keys()}

    # Usa il percorso completo per caricare il file storico.txt
    storico_file_path = os.path.join(percorso_estrazione, 'storico.txt')
    dati = carica_dati_da_file(storico_file_path) # Usa il percorso completo

    for line in dati:
        parts = line.split()
        if len(parts) < 2:
            continue
        date = parts[0]
        ruota = parts[1]

        if data_inizio <= date <= data_fine:
            # Gestione della ruota Nazionale (RN -> NZ)
            if ruota == "RN":
                ruota = "NZ"
                parts[1] = "NZ"  # Modifica la ruota nella linea
                line = ' '.join(parts)  # Ricostruisci la linea con "NZ"

            if ruota in tutti_dati_filtrati:
                tutti_dati_filtrati[ruota].append(line)

    tutti_dati_filtrati = {ruota: lines for ruota, lines in tutti_dati_filtrati.items() if lines}

    if not tutti_dati_filtrati:
        messagebox.showinfo("Info", "Nessun dato trovato per le ruote specificate e le date.")
        return

    salva_dati_su_file(tutti_dati_filtrati)
    messagebox.showinfo("Successo", "Dati aggiornati per tutte le ruote.")

def aggiorna_tutti_file():
    # Specifica il percorso di estrazione
    # percorso_estrazione = r'C:\TUO PERCORSO \Python\Python312' # NON SERVE PIU', USA LA COSTANTE GLOBALE

    if scarica_e_estrai_zip("https://www.igt.it/STORICO_ESTRAZIONI_LOTTO/storico.zip", PERCORSO_ESTRAZIONE):
        # Correggi RN in NZ nel file storico.txt appena scaricato
        storico_file_path = os.path.join(PERCORSO_ESTRAZIONE, 'storico.txt') # Percorso completo
        try:
            with open(storico_file_path, 'r') as file:
                lines = file.readlines()

            with open(storico_file_path, 'w') as file:
                for line in lines:
                    file.write(line.replace(' RN ', ' NZ '))
        except Exception as e:
            messagebox.showerror("Errore", f"Errore durante la correzione RN -> NZ: {e}")
            return # Importante uscire in caso di errore

        if os.path.exists(storico_file_path):
            data_inizio = data_inizio_entry.get()
            data_fine = data_fine_entry.get()

            if not data_inizio:
                messagebox.showerror("Errore", "Inserisci una data di inizio.")
                return

            aggiorna_file(data_inizio, data_fine, PERCORSO_ESTRAZIONE) # Passa il percorso alla funzione
        else:
            messagebox.showerror("Errore", "Il file storico.txt non è stato trovato dopo l'estrazione.")
    else:
        messagebox.showerror("Errore", "Il download del file storico.zip è fallito.")

def crea_file():
    global mappa_ruote
    mappa_ruote = {
        "BA": "Bari.txt",
        "CA": "Cagliari.txt",
        "FI": "Firenze.txt",
        "GE": "Genova.txt",
        "MI": "Milano.txt",
        "NA": "Napoli.txt",
        "PA": "Palermo.txt",
        "RM": "Roma.txt",
        "NZ": "Nazionale.txt",
        "TO": "Torino.txt",
        "VE": "Venezia.txt"
    }
    for ruota in mappa_ruote:
        nome_file = os.path.join(PERCORSO_ESTRAZIONE, mappa_ruote[ruota]) # Percorso completo
        try:
            if not os.path.exists(nome_file):
                open(nome_file, 'w').close()  # Crea un file vuoto
                print(f"File {nome_file} creato in {PERCORSO_ESTRAZIONE}.")
        except Exception as e:
            messagebox.showerror("Errore", f"Errore durante la creazione del file {nome_file}: {e}")
            return # Esci dalla funzione in caso di errore
    messagebox.showinfo("Successo", "Tutti i file mancanti sono stati creati.")


# Creazione della finestra principale
root = tk.Tk()
root.title("Aggiornamento Dati Lotto")

data_inizio_var = tk.StringVar()
data_fine_var = tk.StringVar()

tk.Label(root, text="Data di Inizio (AAAA/MM/GG):").grid(row=0, column=0, padx=10, pady=10)
data_inizio_entry = tk.Entry(root, textvariable=data_inizio_var)
data_inizio_entry.grid(row=0, column=1, padx=10, pady=10)

tk.Label(root, text="Data di Fine (AAAA/MM/GG):").grid(row=1, column=0, padx=10, pady=10)
data_fine_entry = tk.Entry(root, textvariable=data_fine_var)
data_fine_entry.grid(row=1, column=1, padx=10, pady=10)

tk.Button(root, text="Aggiorna Tutti i File", command=aggiorna_tutti_file).grid(row=2, column=0, columnspan=2, padx=10, pady=10)
tk.Button(root, text="Crea File Mancanti", command=crea_file).grid(row=3, column=0, columnspan=2, padx=10, pady=10)

root.mainloop()

Grazie per la gentilezza e la risposta tempestiva , Scarico e mi applico

, nel frattempo avevo intuito e ho creato un file VB6 che crea le estrazione utilizzando l'archivio di spaziometria ed ero riuscito ha fare uno scan con tanto di grafico finale lo script devo affinarlo per sistemare alcune piccole cose . quando sarà ok lo rendo disponibile . per quanto riguarda la directory io ho messo le estraz delle ruote insieme allo script prova1.py e la cosa ha funzionato. Buona giornata a tutti ;.)

batty · Giovedì alle 14:14

sperando di aver fatto cosa gradita ecco l'eseguibile .EXE che crea l'archivio delle 11 ruote compatibile con lo script Python, va levato il suffisso ".TXT" finale. All'inizio dell'esecuzione viene chiesto il percorso della directory da digitare o incollare senza l'ultimo slash "\" lo aggiunge in automatico.
si basa sull'archivio di spaziometria quindi deve ovviamente essere installato nei vostri PC.

x LottoPYTHON Adesso do un'occhiata al codice che mi hai gentilmente passato .
Poi comincerò a rompervi i cojoness con i parametri per ottimizzare la rete

Lottopython · Giovedì alle 14:55

batty ha scritto:
sperando di aver fatto cosa gradita ecco l'eseguibile .EXE che crea l'archivio delle 11 ruote compatibile con lo script Python, va levato il suffisso ".TXT" finale. All'inizio dell'esecuzione viene chiesto il percorso della directory da digitare o incollare senza l'ultimo slash "\" lo aggiunge in automatico.
si basa sull'archivio di spaziometria quindi deve ovviamente essere installato nei vostri PC.

x LottoPYTHON Adesso do un'occhiata al codice che mi hai gentilmente passato .
Poi comincerò a rompervi i cojoness con i parametri per ottimizzare la rete

ti ringrazio batty per quanto proposto appena possibile gli do un occhiata.
buona serata

Lottopython · Giovedì alle 15:36

giuste convergenze e intuizioni possono portare all'ambo in terzina in pochi colpi

i file txt li ho caricati online il codice preleva i dati da github

un piccolo programmino che mi ha dato qualche soddisfazione

N.B
non sono codici in vendita in alcun modo da nessuna parte ,sono liberi da poter essere modificati a proprio piacimento in base alla voglia e alle vostre capacità .

Codice:

[/CENTER]
import tkinter as tk
from tkinter import messagebox, filedialog
import pandas as pd
from scipy.stats import binom
import requests
from io import StringIO
import threading
import time

def carica_dati(url, start_date=None, end_date=None):
    try:
        response = requests.get(url)
        response.raise_for_status()  # Verifica se la richiesta ha avuto successo
        data = StringIO(response.text)
        df = pd.read_csv(data, sep='\t', header=None, names=['Data', 'Ruota', 'Numero1', 'Numero2', 'Numero3', 'Numero4', 'Numero5'])
        df['Data'] = pd.to_datetime(df['Data'], errors='coerce')
        df = df.dropna(subset=['Data'])
        if start_date and end_date:
            df = df[(df['Data'] >= start_date) & (df['Data'] <= end_date)]
        for colonna in ['Numero1', 'Numero2', 'Numero3', 'Numero4', 'Numero5']:
            df[colonna] = df[colonna].apply(lambda x: str(int(x)).zfill(2) if pd.notna(x) and str(x).isdigit() else None)
        return df
    except requests.exceptions.RequestException as e:
        messagebox.showerror("Errore di Rete", f"Errore durante il recupero dei dati dall'URL: {e}")
        return None
    except ValueError as e:
        messagebox.showerror("Errore di Formattazione", f"Errore nel file scaricato: {e}")
        return None

def calcola_statistiche_numeri_successivi(df, numero):
    df_numeri = df[['Numero1', 'Numero2', 'Numero3', 'Numero4', 'Numero5']]
    filtro_successivi = df_numeri.shift(1).apply(lambda x: x == numero).any(axis=1)
    numeri_successivi = df[filtro_successivi].iloc[:, 2:].values.flatten()
    numeri_successivi = pd.Series(numeri_successivi).dropna()
    
    filtro_precedenti = df_numeri.shift(-1).apply(lambda x: x == numero).any(axis=1)
    numeri_precedenti = df[filtro_precedenti].iloc[:, 2:].values.flatten()
    numeri_precedenti = pd.Series(numeri_precedenti).dropna()

    if numeri_successivi.empty and numeri_precedenti.empty:
        return None, f"Il numero {numero} non ha seguito né preceduto immediato sulla ruota."
    
    statistiche = {}
    
    if not numeri_successivi.empty:
        conteggio_numeri_successivi = numeri_successivi.value_counts()
        numeri_top_successivi = conteggio_numeri_successivi.head(4)
        percentuali_successivi = (numeri_top_successivi / len(numeri_successivi)) * 100
        media_successivi = numeri_successivi.astype(int).mean()
        deviazione_standard_successivi = numeri_successivi.astype(int).std()
        statistiche['successivi'] = {
            'numeri_top': numeri_top_successivi,
            'percentuali': percentuali_successivi,
            'media': media_successivi,
            'deviazione_standard': deviazione_standard_successivi,
            'dati': numeri_successivi
        }

    if not numeri_precedenti.empty:
        conteggio_numeri_precedenti = numeri_precedenti.value_counts()
        numeri_top_precedenti = conteggio_numeri_precedenti.head(4)
        percentuali_precedenti = (numeri_top_precedenti / len(numeri_precedenti)) * 100
        media_precedenti = numeri_precedenti.astype(int).mean()
        deviazione_standard_precedenti = numeri_precedenti.astype(int).std()
        statistiche['precedenti'] = {
            'numeri_top': numeri_top_precedenti,
            'percentuali': percentuali_precedenti,
            'media': media_precedenti,
            'deviazione_standard': deviazione_standard_precedenti,
            'dati': numeri_precedenti
        }
    
    freq_uscita_numero = (df.iloc[:, 2:] == numero).sum().sum() / (len(df) * 5)

    def calcola_estrazioni_necessarie(probabilita, freq):
        estrazioni = 1
        while True:
            probabilita_attuale = 1 - binom.cdf(0, estrazioni, freq)
            if probabilita_attuale >= probabilita:
                return estrazioni
            estrazioni += 1

    estrazioni_50_percento = calcola_estrazioni_necessarie(0.50, freq_uscita_numero)
    estrazioni_90_percento = calcola_estrazioni_necessarie(0.90, freq_uscita_numero)

    return (statistiche, freq_uscita_numero, estrazioni_50_percento, estrazioni_90_percento), None

def scegli_miglior_ruota(risultati):
    miglior_ruota = None
    miglior_valutazione = -float('inf')
    
    for ruota, risultato in risultati:
        statistiche, freq_uscita_numero, estrazioni_50_percento, estrazioni_90_percento = risultato
        valutazione = 0
        if 'successivi' in statistiche:
            valutazione += statistiche['successivi']['media'] - statistiche['successivi']['deviazione_standard']
        if 'precedenti' in statistiche:
            valutazione += statistiche['precedenti']['media'] - statistiche['precedenti']['deviazione_standard']
        
        if valutazione > miglior_valutazione:
            miglior_valutazione = valutazione
            miglior_ruota = (ruota, risultato)
    
    return miglior_ruota

def cerca_numeri():
    ruote_selezionate = listbox_ruote.curselection()
    if not ruote_selezionate:
        messagebox.showinfo("Nessuna Ruota Selezionata", "Seleziona almeno una ruota.")
        return

    numeri_spia = [entry.get().zfill(2) for entry in entry_numeri if entry.get().isdigit() and 1 <= int(entry.get()) <= 90]
    if not numeri_spia:
        messagebox.showinfo("Numeri Spia Invalidi", "Inserisci numeri spia validi (1-90).")
        return
    
    try:
        start_date = pd.to_datetime(start_date_entry.get(), format='%Y-%m-%d')
        end_date = pd.to_datetime(end_date_entry.get(), format='%Y-%m-%d')
    except ValueError:
        messagebox.showinfo("Date Invalidi", "Inserisci date valide nel formato YYYY-MM-DD.")
        return

    risultati = []
    messaggi_errore = []
    for ruota_index in ruote_selezionate:
        ruota = listbox_ruote.get(ruota_index)
        file_ruota = file_ruote.get(ruota)
        if file_ruota:
            df = carica_dati(file_ruota, start_date, end_date)
            if df is not None:
                for numero in numeri_spia:
                    risultato, errore = calcola_statistiche_numeri_successivi(df, numero)
                    if errore:
                        messaggi_errore.append(errore)
                    if risultato is not None:
                        risultati.append((ruota, risultato))

    if risultati:
        miglior_ruota = scegli_miglior_ruota(risultati)
        if miglior_ruota:
            ruota, risultato = miglior_ruota
            statistiche, freq_uscita_numero, estrazioni_50_percento, estrazioni_90_percento = risultato

            messaggio = f"Per la ruota di {ruota}, le statistiche dei numeri spia sono:\n"
            
            if 'successivi' in statistiche:
                messaggio += "Numeri successivi:\n"
                for num, freq in statistiche['successivi']['numeri_top'].items():
                    percentuale = statistiche['successivi']['percentuali'][num]
                    messaggio += f"- Numero: {num}, Frequenza: {freq}, Percentuale: {percentuale:.2f}%\n"
                messaggio += f"Media dei numeri successivi: {statistiche['successivi']['media']:.2f}\n"
                messaggio += f"Deviazione standard dei numeri successivi: {statistiche['successivi']['deviazione_standard']:.2f}\n"
            
            if 'precedenti' in statistiche:
                messaggio += "Numeri precedenti:\n"
                for num, freq in statistiche['precedenti']['numeri_top'].items():
                    percentuale = statistiche['precedenti']['percentuali'][num]
                    messaggio += f"- Numero: {num}, Frequenza: {freq}, Percentuale: {percentuale:.2f}%\n"
                messaggio += f"Media dei numeri precedenti: {statistiche['precedenti']['media']:.2f}\n"
                messaggio += f"Deviazione standard dei numeri precedenti: {statistiche['precedenti']['deviazione_standard']:.2f}\n"
            
            messaggio += f"Frequenza di uscita del numero spia: {freq_uscita_numero:.2f}\n"
            messaggio += f"Numero stimato di estrazioni necessarie per avere il numero spia con probabilità del 50%: {estrazioni_50_percento}\n"
            messaggio += f"Numero stimato di estrazioni necessarie per avere il numero spia con probabilità del 90%: {estrazioni_90_percento}\n"
            messaggio += "\n"
        
            risultato_text.delete(1.0, tk.END)
            risultato_text.insert(tk.END, messaggio)
    else:
        risultato_text.delete(1.0, tk.END)
        if messaggi_errore:
            risultato_text.insert(tk.END, "\n".join(messaggi_errore))
        else:
            risultato_text.insert(tk.END, "Nessun risultato trovato.")

def salva_risultati():
    results = risultato_text.get(1.0, tk.END)
    if not results.strip():
        messagebox.showinfo("Nessun Risultato", "Non ci sono risultati da salvare.")
        return
    file_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files", "*.txt")])
    if file_path:
        with open(file_path, "w") as file:
            file.write(results)
        messagebox.showinfo("Salvataggio", "I risultati sono stati salvati correttamente.")

def ottieni_data_ultima_estrazione(url):
    try:
        response = requests.get(url)
        response.raise_for_status()
        data = StringIO(response.text)
        df = pd.read_csv(data, sep='\t', header=None, names=['Data', 'Ruota', 'Numero1', 'Numero2', 'Numero3', 'Numero4', 'Numero5'])
        df['Data'] = pd.to_datetime(df['Data'], errors='coerce')
        df = df.dropna(subset=['Data'])
        if not df.empty:
            ultima_estrazione = df.iloc[-1]['Data']
            return ultima_estrazione.strftime('%Y/%m/%d')
        else:
            return "Data non disponibile"
    except requests.exceptions.RequestException as e:
        return f"Errore di rete: {e}"
    except ValueError as e:
        return f"Errore di formato: {e}"

def aggiorna_data_estrazione():
    global ultima_estrazione_label
    # URL del file da cui prelevare la data (es. BARI)
    url_bari = 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/BARI.txt'
    data_ultima_estrazione = ottieni_data_ultima_estrazione(url_bari)
    ultima_estrazione_label.config(text=f"Aggiornato alla data del: {data_ultima_estrazione}")
    root.after(60000, aggiorna_data_estrazione)  # Aggiorna ogni 60 secondi

# Definizione della finestra principale
root = tk.Tk()
root.title("Analisi dei Numeri Spia")
root.geometry("1200x700")

# Definisci gli URL dei file delle ruote
file_ruote = {
    'BA': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/BARI.txt',
    'CA': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/CAGLIARI.txt',
    'FI': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/FIRENZE.txt',
    'GE': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/GENOVA.txt',
    'MI': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/MILANO.txt',
    'NA': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/NAPOLI.txt',
    'PA': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/PALERMO.txt',
    'RM': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/ROMA.txt',
    'TO': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/TORINO.txt',
    'VE': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/VENEZIA.txt',
    'NZ': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/NAZIONALE.txt'
}

frame = tk.Frame(root, padx=10, pady=10)
frame.pack(expand=True, fill=tk.BOTH)

# Etichetta per l'ultima estrazione (box aggiunto)
ultima_estrazione_label = tk.Label(frame, text="Caricamento data...", font=("Helvetica", 14))
ultima_estrazione_label.place(relx=0.05, rely=0.01, relwidth=0.9, relheight=0.1)

label_ruote = tk.Label(frame, text="Seleziona Ruota:", font=("Helvetica", 14))
label_ruote.place(relx=0.05, rely=0.15, relwidth=0.15, relheight=0.05)

listbox_ruote = tk.Listbox(frame, font=("Helvetica", 12), selectmode=tk.MULTIPLE)
for ruota in file_ruote.keys():
    listbox_ruote.insert(tk.END, ruota)
listbox_ruote.place(relx=0.05, rely=0.2, relwidth=0.15, relheight=0.35)

label_numeri_spia = tk.Label(frame, text="Numeri Spia:", font=("Helvetica", 14))
label_numeri_spia.place(relx=0.25, rely=0.15, relwidth=0.2, relheight=0.05)

entry_numeri = []
for i in range(5):
    entry_numero = tk.Entry(frame, font=("Helvetica", 12))
    entry_numero.place(relx=0.25, rely=0.2 + i * 0.07, relwidth=0.2, relheight=0.05)
    entry_numeri.append(entry_numero)

start_date_label = tk.Label(frame, text="Data Inizio:", font=("Helvetica", 14))
start_date_label.place(relx=0.55, rely=0.15, relwidth=0.15, relheight=0.05)

start_date_entry = tk.Entry(frame, font=("Helvetica", 12))
start_date_entry.place(relx=0.55, rely=0.2, relwidth=0.2, relheight=0.05)

end_date_label = tk.Label(frame, text="Data Fine:", font=("Helvetica", 14))
end_date_label.place(relx=0.55, rely=0.3, relwidth=0.15, relheight=0.05)

end_date_entry = tk.Entry(frame, font=("Helvetica", 12))
end_date_entry.place(relx=0.55, rely=0.35, relwidth=0.2, relheight=0.05)

button_cerca = tk.Button(frame, text="Cerca", font=("Helvetica", 14), command=cerca_numeri)
button_cerca.place(relx=0.8, rely=0.2, relwidth=0.15, relheight=0.1)

button_salva = tk.Button(frame, text="Salva Risultati", font=("Helvetica", 14), command=salva_risultati)
button_salva.place(relx=0.8, rely=0.35, relwidth=0.15, relheight=0.1)

risultato_text = tk.Text(frame, font=("Helvetica", 12))
risultato_text.place(relx=0.05, rely=0.6, relwidth=0.9, relheight=0.35)

# Avvia l'aggiornamento iniziale delle estrazioni e il loop
aggiorna_data_estrazione()

root.mainloop()
[CENTER]

max63 · Venerdì alle 01:14

Piccole e lievi modifiche ad un costrutto ...Adesso il gioco si fa duro...molto duro!

ciao a tutti!

lotto_tom75 · Venerdì alle 14:48

Non ho ancora scaricato nulla o visto nulla ma complimenti a tutti per l'impegno e le cose che avete costruito che a giudicare solo dagli screenshots e il testo relativo sembrano davvero molto ben fatte e interessanti

Vi lascio questo video tutorial di un ragazzo, tra i maggiori esperti di AI che seguo, che mi pare proprio in tema con questo thread di lottopython. Io ancora non ho provato nemmeno a fare quanto dice ma credo che chi ci riuscisse avrebbe qualcosa di molto interessante da aggiungere al proprio arsenale lotto ludico

max63 · Venerdì alle 15:35

Grazie Lotto_Tom...faccio tesoro...e cerco di imparare da te e da tutti!..Grazie mille...gentilissimo

max63 · Venerdì alle 15:44

Implementazione completa di un'interfaccia grafica (GUI) per la previsione dei numeri del lotto utilizzando il machine learning. Utilizza TensorFlow e Keras per l'addestramento e la previsione del modello, e Tkinter per la GUI. Ecco una panoramica delle componenti e funzionalità principali:

Componenti Chiave

Caricamento Dati:

La funzione carica_dati carica i dati del lotto da file specificati in un intervallo di date.
I dati vengono normalizzati dividendo per 90.

Addestramento del Modello:

Il modello è una rete neurale profonda con diversi strati densi, dropout e normalizzazione batch.
È possibile selezionare vari ottimizzatori (Adam, RMSprop, ecc.) e funzioni di perdita (MSE, MAE, ecc.).
Vengono utilizzati callback per l'early stopping, il salvataggio del modello e la riduzione del tasso di apprendimento per migliorare l'addestramento.

Previsione:

Il modello prevede il prossimo set di numeri del lotto.
Le previsioni possono essere effettuate utilizzando la validazione incrociata o un insieme di modelli (ensemble).

Interfaccia Grafica (GUI):

Realizzata con Tkinter, la GUI permette agli utenti di selezionare la ruota del lotto, l'intervallo di date, i parametri di addestramento, l'ottimizzatore e la funzione di perdita.
Mostra i risultati delle previsioni e un grafico dell'andamento della perdita durante l'addestramento.

Funzionalità Aggiuntive:

La GUI include opzioni per l'early stopping, la validazione incrociata e l'ensemble learning.
È presente un pulsante per eseguire uno script esterno (aggiornamento.py) per aggiornare i dati delle estrazioni del lotto.

Funzionamento

Selezione della Ruota: Scegliere tra le ruote del lotto disponibili (es. Bari, Cagliari).
Impostazione Intervallo di Date: Specificare le date di inizio e fine per i dati di addestramento.
Scelta di Ottimizzatore e Funzione di Perdita: Selezionare tra le opzioni disponibili.
Impostazione Parametri di Addestramento: Inserire il numero di epoche, la dimensione del batch e il tasso di apprendimento.
Opzioni di Addestramento: Abilitare l'early stopping, la validazione incrociata o l'ensemble learning se desiderato.
Avvio della Previsione: Cliccare sul pulsante per addestrare il modello e fare previsioni.
Visualizzazione Risultati: Vedere i numeri previsti e il grafico della perdita di addestramento.

....e tanto altro ancora
Note

Assicurarsi che i file dei dati del lotto (es. Bari.txt) siano correttamente formattati e accessibili.
Lo script aggiornamento.py ( gentilmente offerto da Lottopython) deve essere disponibile nella stessa directory per il funzionamento del pulsante di aggiornamento.
Il codice presuppone che TensorFlow e altre dipendenze siano installate nell'ambiente.

Questa implementazione fornisce un'interfaccia user-friendly per la previsione dei numeri del lotto utilizzando il machine learning, con diverse opzioni di personalizzazione per l'addestramento e la previsione.

Possibilita di creare il modello o i modelli su una o piu' ruote...
I lavori continuano

Ciao e grazie a tutti per ogni tipo di aiuto e/o suggerimento

Lottopython · Venerdì alle 16:17

max63 ha scritto:
Implementazione completa di un'interfaccia grafica (GUI) per la previsione dei numeri del lotto utilizzando il machine learning. Utilizza TensorFlow e Keras per l'addestramento e la previsione del modello, e Tkinter per la GUI. Ecco una panoramica delle componenti e funzionalità principali:

Componenti Chiave

Caricamento Dati:

La funzione carica_dati carica i dati del lotto da file specificati in un intervallo di date.

I dati vengono normalizzati dividendo per 90.

Addestramento del Modello:

Il modello è una rete neurale profonda con diversi strati densi, dropout e normalizzazione batch.

È possibile selezionare vari ottimizzatori (Adam, RMSprop, ecc.) e funzioni di perdita (MSE, MAE, ecc.).

Vengono utilizzati callback per l'early stopping, il salvataggio del modello e la riduzione del tasso di apprendimento per migliorare l'addestramento.

Previsione:

Il modello prevede il prossimo set di numeri del lotto.

Le previsioni possono essere effettuate utilizzando la validazione incrociata o un insieme di modelli (ensemble).

Interfaccia Grafica (GUI):

Realizzata con Tkinter, la GUI permette agli utenti di selezionare la ruota del lotto, l'intervallo di date, i parametri di addestramento, l'ottimizzatore e la funzione di perdita.

Mostra i risultati delle previsioni e un grafico dell'andamento della perdita durante l'addestramento.

Funzionalità Aggiuntive:

La GUI include opzioni per l'early stopping, la validazione incrociata e l'ensemble learning.

È presente un pulsante per eseguire uno script esterno (aggiornamento.py) per aggiornare i dati delle estrazioni del lotto.

Funzionamento

Selezione della Ruota: Scegliere tra le ruote del lotto disponibili (es. Bari, Cagliari).

Impostazione Intervallo di Date: Specificare le date di inizio e fine per i dati di addestramento.

Scelta di Ottimizzatore e Funzione di Perdita: Selezionare tra le opzioni disponibili.

Impostazione Parametri di Addestramento: Inserire il numero di epoche, la dimensione del batch e il tasso di apprendimento.

Opzioni di Addestramento: Abilitare l'early stopping, la validazione incrociata o l'ensemble learning se desiderato.

Avvio della Previsione: Cliccare sul pulsante per addestrare il modello e fare previsioni.

Visualizzazione Risultati: Vedere i numeri previsti e il grafico della perdita di addestramento.

....e tanto altro ancora
Note

Assicurarsi che i file dei dati del lotto (es. Bari.txt) siano correttamente formattati e accessibili.

Lo script aggiornamento.py ( gentilmente offerto da Lottopython) deve essere disponibile nella stessa directory per il funzionamento del pulsante di aggiornamento.

Il codice presuppone che TensorFlow e altre dipendenze siano installate nell'ambiente.

Questa implementazione fornisce un'interfaccia user-friendly per la previsione dei numeri del lotto utilizzando il machine learning, con diverse opzioni di personalizzazione per l'addestramento e la previsione.

Possibilita di creare il modello o i modelli su doppia ruota...
I lavori continuano

Ciao e grazie a tutti per ogni tipo di aiuto e/o suggerimento

piccolo screen

ciao max ciao a tutti
mi sono permesso di implementare l'analisi ruote direttamente da file txt su gthub ,non c'è piu bisogno di avere i txt in cartella o il programma aggiornamento , basta aggiornare una volta sola i file online appena disponibile lo storico , sto cercando di implementare una sorta di automatismo fare i modo che lo storico aggiorni automaticamente i file su github ,l'idea sarebbe di impostare un orario x ed eseguire uno scan ogni 60 sec per l'aggiornamento da ora ad ora. Al momento è questo incollo il codice di Max leggermente modificato affinchè legga le ruote su github mostri a terminale la ruota selezionata con l'ultima data d'estrazione attiva

Per @max63 secondo te come possiamo implementare la voce: ruote probabili?

Codice:

import pandas as pd
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization
from tensorflow.keras.optimizers import Adam, RMSprop, SGD, Adagrad, Adadelta, Adamax, Nadam
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from tensorflow.keras.losses import MeanSquaredLogarithmicError, Huber, LogCosh, MeanSquaredError, MeanAbsoluteError
from sklearn.model_selection import KFold
import tkinter as tk
from tkinter import messagebox, ttk
from tkcalendar import DateEntry
import os
import random
import matplotlib.pyplot as plt
import requests
import io  # Importa il modulo io

# Aggiunta di colorama per il testo colorato nel terminale
import colorama
from colorama import Fore, Style
colorama.init()

# Imposta i semi casuali per garantire riproducibilità
def set_seed(seed_value=42):
    os.environ['PYTHONHASHSEED'] = str(seed_value)
    random.seed(seed_value)
    np.random.seed(seed_value)
    tf.random.set_seed(seed_value)

set_seed()

# Definisci gli URL dei file delle ruote
file_ruote = {
    'BA': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/BARI.txt',
    'CA': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/CAGLIARI.txt',
    'FI': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/FIRENZE.txt',
    'GE': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/GENOVA.txt',
    'MI': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/MILANO.txt',
    'NA': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/NAPOLI.txt',
    'PA': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/PALERMO.txt',
    'RM': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/ROMA.txt',
    'TO': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/TORINO.txt',
    'VE': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/VENEZIA.txt',
    'NZ': 'https://raw.githubusercontent.com/Lottopython/estrazioni/refs/heads/main/NAZIONALE.txt'
}

# Variabili globali per salvare le scelte
selected_ruota = None
selected_optimizer = None
selected_loss = None
numeri_interi = []
ultima_estrazione_label = None # variabile globale per la label
data_ultima_estrazione = "Data non disponibile" # inizializza la variabile globale

# Valori consigliati per i parametri di addestramento
suggested_values = {
    "Adam": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
    "RMSprop": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
    "SGD": {"epochs": 100, "batch_size": 64, "learning_rate": 0.01},
    "Adagrad": {"epochs": 100, "batch_size": 64, "learning_rate": 0.01},
    "Adadelta": {"epochs": 100, "batch_size": 64, "learning_rate": 1.0},
    "Adamax": {"epochs": 100, "batch_size": 64, "learning_rate": 0.002},
    "Nadam": {"epochs": 100, "batch_size": 64, "learning_rate": 0.002},
    "mse": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
    "mae": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
    "msle": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
    "huber": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
    "logcosh": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001}
}

# Funzione per caricare i dati della ruota selezionata
def carica_dati(ruota, start_date, end_date):
    file_url = file_ruote.get(ruota)
    if not file_url:
        messagebox.showerror("Errore", "Ruota non trovata.")
        return None, None

    try:
        response = requests.get(file_url)
        response.raise_for_status()
        data = pd.read_csv(io.StringIO(response.text), header=None, sep="\t")
        data.iloc[:, 0] = pd.to_datetime(data.iloc[:, 0], format='%Y/%m/%d')
        mask = (data.iloc[:, 0] >= start_date) & (data.iloc[:, 0] <= end_date)
        data = data.loc[mask]
        numeri = data.iloc[:, 2:].values
        
        if numeri.size == 0:
            messagebox.showerror("Errore", "Nessun dato trovato per l'intervallo selezionato.")
            return None, None

        numeri = numeri / 90.0
        return numeri[:-1], numeri[1:]
    except requests.exceptions.RequestException as e:
        messagebox.showerror("Errore", f"Errore durante il recupero dei dati: {str(e)}")
        return None, None
    except Exception as e:
        messagebox.showerror("Errore", str(e))
        return None, None

# Funzione per validare gli input e ottenere le date nel formato corretto
def validate_input():
    try:
        start_date_obj = entry_start.get_date()
        end_date_obj = entry_end.get_date()
        start_date = pd.to_datetime(start_date_obj.strftime('%Y/%m/%d'))
        end_date = pd.to_datetime(end_date_obj.strftime('%Y/%m/%d'))

        if start_date >= end_date:
            raise ValueError("La data di inizio deve essere precedente alla data di fine.")

        epochs = int(entry_epochs.get())
        if epochs <= 0:
            raise ValueError("Il numero di epoche deve essere positivo.")

        batch_size = int(entry_batch_size.get())
        if batch_size <= 0:
            raise ValueError("Il batch size deve essere positivo.")

        learning_rate = float(entry_learning_rate.get())
        if learning_rate <= 0:
            raise ValueError("Il learning rate deve essere positivo.")

        return start_date, end_date, epochs, batch_size, learning_rate

    except ValueError as e:
        messagebox.showerror("Errore", str(e))
        return None

# Funzione per aggiornare lo stato
def update_status(message):
    status_bar.config(text=message)
    root.update_idletasks()

# Funzione per valutare la perdita di validazione
def valuta_val_loss(val_loss):
    if val_loss < 0.05:
        return "Ottimale"
    elif val_loss < 0.1:
        return "Discreto"
    elif val_loss < 0.2:
        return "Sufficiente"
    else:
        return "Scarso"

# Definisci la funzione TensorFlow al di fuori del ciclo
@tf.function(reduce_retracing=True)
def make_prediction_function(model, data):
    return model(data, training=False)

# Funzione per avviare la previsione
def avvia_previsione():
    global numeri_interi, data_ultima_estrazione
    update_status("Inizio della previsione...")

    if not selected_ruota or not selected_optimizer or not selected_loss:
        update_status("Errore: Selezionare ruota, ottimizzatore e funzione di perdita.")
        return

    print(Fore.GREEN + f"Ruota Selezionata: {selected_ruota}" + Style.RESET_ALL)
    print(Fore.GREEN + f"Ultima Data di Estrazione: {data_ultima_estrazione}" + Style.RESET_ALL)

    validation = validate_input()
    if not validation:
        return

    start_date, end_date, epochs, batch_size, learning_rate = validation
    update_status("Caricamento dati...")
    X, y = carica_dati(selected_ruota, start_date, end_date)
    if X is None or y is None:
        return

    if use_cross_validation.get():
        kfold = KFold(n_splits=5, shuffle=True, random_state=42)
        val_losses = []
        predictions = []

        for train_index, val_index in kfold.split(X):
            update_status("Addestramento del modello...")

            X_train, X_val = X[train_index], X[val_index]
            y_train, y_val = y[train_index], y[val_index]

            model = Sequential([
                Dense(1024, input_shape=(X.shape[1],), activation="relu"),
                BatchNormalization(),
                Dropout(0.5),
                Dense(512, activation="relu"),
                BatchNormalization(),
                Dropout(0.5),
                Dense(256, activation="relu"),
                BatchNormalization(),
                Dropout(0.5),
                Dense(y.shape[1], activation="linear")
            ])

            optimizer = {
                'Adam': Adam(learning_rate=learning_rate),
                'RMSprop': RMSprop(learning_rate=learning_rate),
                'SGD': SGD(learning_rate=learning_rate),
                'Adagrad': Adagrad(learning_rate=learning_rate),
                'Adadelta': Adadelta(learning_rate=learning_rate),
                'Adamax': Adamax(learning_rate=learning_rate),
                'Nadam': Nadam(learning_rate=learning_rate)
            }[selected_optimizer]

            loss_function = {
                "mse": MeanSquaredError(),
                "mae": MeanAbsoluteError(),
                "msle": MeanSquaredLogarithmicError(),
                "huber": Huber(),
                "logcosh": LogCosh()
            }[selected_loss]

            metrics_dict = {
                "mse": MeanSquaredError(),
                "mae": MeanAbsoluteError(),
                "msle": MeanSquaredLogarithmicError(),
                "huber": Huber(),
                "logcosh": LogCosh()
            }
            metric = metrics_dict[selected_loss]

            model.compile(optimizer=optimizer, loss=loss_function, metrics=[metric])

            callbacks = []
            if use_early_stopping.get():
                early_stopping = EarlyStopping(monitor='val_loss', patience=15, restore_best_weights=True)
                callbacks.append(early_stopping)

            checkpoint = ModelCheckpoint('best_model.keras', monitor='val_loss', save_best_only=True)
            reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, min_lr=1e-6)
            callbacks.extend([checkpoint, reduce_lr])

            # Addestramento del modello
            history = model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=1,
                                validation_data=(X_val, y_val), callbacks=callbacks)

            val_losses.append(min(history.history['val_loss']))

            model.load_weights('best_model.keras')

            next_prediction = make_prediction_function(model, X[-1:])
            predictions.append(next_prediction.numpy())

        ensemble_prediction = np.mean(predictions, axis=0)
        numeri_interi = np.clip(np.round(ensemble_prediction * 90).astype(int), 1, 90).flatten()

        media_val_loss = np.mean(val_losses)
        valutazione = valuta_val_loss(media_val_loss)

        text_output.delete('1.0', tk.END)
        text_output.insert(tk.END, f"Dati utilizzati per la previsione:\n{', '.join(map(str, numeri_interi))}\n")
        text_output.insert(tk.END, f"Media val_loss in validazione incrociata: {media_val_loss:.4f}\n")
        text_output.insert(tk.END, f"Valutazione: {valutazione}\n")

        plot_loss(history)
        update_status("Previsione completata")

    else:
        update_status("Addestramento del modello...")

        predictions = []
        if use_ensemble.get():
            num_models = int(spinbox_num_models.get())
            for i in range(num_models):
                model = Sequential([
                    Dense(1024, input_shape=(X.shape[1],), activation="relu"),
                    BatchNormalization(),
                    Dropout(0.5),
                    Dense(512, activation="relu"),
                    BatchNormalization(),
                    Dropout(0.5),
                    Dense(256, activation="relu"),
                    BatchNormalization(),
                    Dropout(0.5),
                    Dense(y.shape[1], activation="linear")
                ])

                optimizer = {
                    'Adam': Adam(learning_rate=learning_rate),
                    'RMSprop': RMSprop(learning_rate=learning_rate),
                    'SGD': SGD(learning_rate=learning_rate),
                    'Adagrad': Adagrad(learning_rate=learning_rate),
                    'Adadelta': Adadelta(learning_rate=learning_rate),
                    'Adamax': Adamax(learning_rate=learning_rate),
                    'Nadam': Nadam(learning_rate=learning_rate)
                }[selected_optimizer]

                loss_function = {
                    "mse": MeanSquaredError(),
                    "mae": MeanAbsoluteError(),
                    "msle": MeanSquaredLogarithmicError(),
                    "huber": Huber(),
                    "logcosh": LogCosh()
                }[selected_loss]

                metrics_dict = {
                    "mse": MeanSquaredError(),
                    "mae": MeanAbsoluteError(),
                    "msle": MeanSquaredLogarithmicError(),
                    "huber": Huber(),
                    "logcosh": LogCosh()
                }
                metric = metrics_dict[selected_loss]

                model.compile(optimizer=optimizer, loss=loss_function, metrics=[metric])

                callbacks = []
                if use_early_stopping.get():
                    early_stopping = EarlyStopping(monitor='val_loss', patience=15, restore_best_weights=True)
                    callbacks.append(early_stopping)

                checkpoint = ModelCheckpoint('best_model.keras', monitor='val_loss', save_best_only=True)
                reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, min_lr=1e-6)
                callbacks.extend([checkpoint, reduce_lr])

                history = model.fit(X, y, epochs=epochs, batch_size=batch_size, verbose=1,
                                    validation_split=0.2, callbacks=callbacks)

                model.load_weights('best_model.keras')

                next_prediction = make_prediction_function(model, X[-1:])
                predictions.append(next_prediction.numpy())

            ensemble_prediction = np.mean(predictions, axis=0)
            numeri_interi = np.clip(np.round(ensemble_prediction * 90).astype(int), 1, 90).flatten()
        else:
            model = Sequential([
                Dense(1024, input_shape=(X.shape[1],), activation="relu"),
                BatchNormalization(),
                Dropout(0.5),
                Dense(512, activation="relu"),
                BatchNormalization(),
                Dropout(0.5),
                Dense(256, activation="relu"),
                BatchNormalization(),
                Dropout(0.5),
                Dense(y.shape[1], activation="linear")
            ])

            optimizer = {
                'Adam': Adam(learning_rate=learning_rate),
                'RMSprop': RMSprop(learning_rate=learning_rate),
                'SGD': SGD(learning_rate=learning_rate),
                'Adagrad': Adagrad(learning_rate=learning_rate),
                'Adadelta': Adadelta(learning_rate=learning_rate),
                'Adamax': Adamax(learning_rate=learning_rate),
                'Nadam': Nadam(learning_rate=learning_rate)
            }[selected_optimizer]

            loss_function = {
                "mse": MeanSquaredError(),
                "mae": MeanAbsoluteError(),
                "msle": MeanSquaredLogarithmicError(),
                "huber": Huber(),
                "logcosh": LogCosh()
            }[selected_loss]

            metrics_dict = {
                "mse": MeanSquaredError(),
                "mae": MeanAbsoluteError(),
                "msle": MeanSquaredLogarithmicError(),
                "huber": Huber(),
                "logcosh": LogCosh()
            }
            metric = metrics_dict[selected_loss]

            model.compile(optimizer=optimizer, loss=loss_function, metrics=[metric])

            callbacks = []
            if use_early_stopping.get():
                early_stopping = EarlyStopping(monitor='val_loss', patience=15, restore_best_weights=True)
                callbacks.append(early_stopping)

            checkpoint = ModelCheckpoint('best_model.keras', monitor='val_loss', save_best_only=True)
            reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, min_lr=1e-6)
            callbacks.extend([checkpoint, reduce_lr])

            history = model.fit(X, y, epochs=epochs, batch_size=batch_size, verbose=1,
                                validation_split=0.2, callbacks=callbacks)

            model.load_weights('best_model.keras')

            next_prediction = make_prediction_function(model, X[-1:])
            numeri_interi = np.clip(np.round(next_prediction.numpy() * 90).astype(int), 1, 90).flatten()

        val_loss = min(history.history['val_loss'])
        valutazione = valuta_val_loss(val_loss)

        text_output.delete('1.0', tk.END)
        text_output.insert(tk.END, f"Dati utilizzati per la previsione:\n{', '.join(map(str, numeri_interi))}\n")
        text_output.insert(tk.END, f"Val Loss: {val_loss:.4f}\n")
        text_output.insert(tk.END, f"Valutazione: {valutazione}\n")

        plot_loss(history)
        update_status("Previsione completata")

# Funzione per visualizzare il grafico delle perdite (loss)
def plot_loss(history):
    plt.figure(figsize=(10, 6))
    plt.plot(history.history['loss'], label='Loss', color='blue')
    plt.plot(history.history['val_loss'], label='Val Loss', color='orange')
    plt.title('Andamento della Loss durante l\'Addestramento')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.legend()
    plt.grid(True)
    plt.show()

# Funzioni per la selezione di ruota, ottimizzatore e funzione di perdita
def seleziona_ruota(ruota):
    global selected_ruota, data_ultima_estrazione
    selected_ruota = ruota

    data_ultima_estrazione = ottieni_data_ultima_estrazione(selected_ruota)
    if ultima_estrazione_label:  # Verifica che la label sia stata creata
        ultima_estrazione_label.config(text=f"Aggiornato alla data del: {data_ultima_estrazione}")

    for frame in frame_ruote.values():
        frame.configure(style="TFrame")
    frame_ruote[ruota].configure(style="Selected.TFrame")

def seleziona_optimizer(opt):
    global selected_optimizer
    selected_optimizer = opt
    for btn in pulsanti_optimizer.values():
        btn.configure(style="TButton")
    pulsanti_optimizer[opt].configure(style="Selected.TButton")
    update_suggested_values()

def seleziona_loss(loss):
    global selected_loss
    selected_loss = loss
    for btn in pulsanti_loss.values():
        btn.configure(style="TButton")
    pulsanti_loss[loss].configure(style="Selected.TButton")
    update_suggested_values()

def update_suggested_values():
    if selected_optimizer and selected_loss:
        optimizer_values = suggested_values.get(selected_optimizer, {})
        loss_values = suggested_values.get(selected_loss, {})

        epochs = optimizer_values.get("epochs", loss_values.get("epochs", 100))
        batch_size = optimizer_values.get("batch_size", loss_values.get("batch_size", 64))
        learning_rate = optimizer_values.get("learning_rate", loss_values.get("learning_rate", 0.001))

        entry_epochs.delete(0, tk.END)
        entry_epochs.insert(0, str(epochs))

        entry_batch_size.delete(0, tk.END)
        entry_batch_size.insert(0, str(batch_size))

        entry_learning_rate.delete(0, tk.END)
        entry_learning_rate.insert(0, str(learning_rate))

# Funzione per ottenere la data dell'ultima estrazione
def ottieni_data_ultima_estrazione(ruota):
    url_file = file_ruote.get(ruota)
    if not url_file:
        return "Data non disponibile"

    try:
        response = requests.get(url_file)
        response.raise_for_status()  # Lancia un'eccezione per codici di stato HTTP errati
        righe = response.content.decode('utf-8').strip().split('\n')
        
        # Controlla se ci sono righe nel file
        if not righe:
            return "Data non disponibile (file vuoto)"
        
        ultima_riga = righe[-1]  # Ottiene l'ultima riga
        data_estrazione = ultima_riga.split('\t')[0]  # Divide la riga e prende la data
        return data_estrazione
    except requests.exceptions.RequestException as e:
        print(f"Errore durante la richiesta HTTP: {e}")
        return "Data non disponibile (errore HTTP)"
    except IndexError as e:
        print(f"Errore: Impossibile trovare la data nell'ultima riga del file.")
        return "Data non disponibile (errore parsing)"
    except Exception as e:
        print(f"Errore durante l'elaborazione: {e}")
        return "Data non disponibile (errore generico)"
# -------------------------- INTERFACCIA GRAFICA --------------------------

# Inizializza la finestra principale
root = tk.Tk()
root.title("Previsione Lotto")
root.geometry("1200x750")

use_early_stopping = tk.BooleanVar(value=True)
use_cross_validation = tk.BooleanVar(value=True)
use_ensemble = tk.BooleanVar(value=True)

style = ttk.Style()
style.theme_use("clam")
style.configure("TLabel", font=("Helvetica", 10), padding=2, background="#f0f0f0")
style.configure("TButton", font=("Helvetica", 10), padding=2, background="#e0e0e0")
style.configure("TFrame", padding=1, background="#f8f8f8")
style.configure("Selected.TButton", background="lightgreen")
style.configure("Selected.TFrame", background="red")

main_frame = ttk.Frame(root, padding="5")
main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))

# --- Selezione della Ruota ---
ruota_frame = ttk.LabelFrame(main_frame, text="Seleziona la Ruota del Lotto", padding="5")
ruota_frame.grid(row=0, column=0, columnspan=2, pady=2, sticky=(tk.W, tk.E))

pulsanti_ruote = {}
frame_ruote = {}
for idx, ruota in enumerate(file_ruote.keys()):
    frame = ttk.Frame(ruota_frame, style="TFrame")
    frame.grid(row=0, column=idx, padx=2)
    pulsanti_ruote[ruota] = ttk.Button(frame, text=ruota, command=lambda r=ruota: seleziona_ruota(r))
    pulsanti_ruote[ruota].pack(padx=2, pady=2)
    frame_ruote[ruota] = frame

# --- Selezione delle Date con tkcalendar ---
date_frame = ttk.LabelFrame(main_frame, text="Seleziona l'Intervallo di Date", padding="5")
date_frame.grid(row=1, column=0, columnspan=2, pady=2, sticky=(tk.W, tk.E))

ttk.Label(date_frame, text="Data di Inizio (YYYY/MM/DD):").grid(row=0, column=0, padx=2)
entry_start = DateEntry(date_frame, date_pattern='yyyy/mm/dd', width=12)
entry_start.grid(row=0, column=1, padx=2)

ttk.Label(date_frame, text="Data di Fine (YYYY/MM/DD):").grid(row=1, column=0, padx=2)
entry_end = DateEntry(date_frame, date_pattern='yyyy/mm/dd', width=12)
entry_end.grid(row=1, column=1, padx=2)

# --- Parametri di Addestramento ---
training_frame = ttk.LabelFrame(main_frame, text="Parametri di Addestramento", padding="5")
training_frame.grid(row=2, column=0, columnspan=2, pady=2, sticky=(tk.W, tk.E))

ttk.Label(training_frame, text="Numero di Epoche:").grid(row=0, column=0, padx=2)
entry_epochs = ttk.Entry(training_frame, width=10)
entry_epochs.grid(row=0, column=1, padx=2)

ttk.Label(training_frame, text="Batch Size:").grid(row=1, column=0, padx=2)
entry_batch_size = ttk.Entry(training_frame, width=10)
entry_batch_size.grid(row=1, column=1, padx=2)

ttk.Label(training_frame, text="Learning Rate:").grid(row=2, column=0, padx=2)
entry_learning_rate = ttk.Entry(training_frame, width=10)
entry_learning_rate.grid(row=2, column=1, padx=2)

# --- Selezione dell'Ottimizzatore ---
optimizer_frame = ttk.LabelFrame(main_frame, text="Seleziona l'Ottimizzatore", padding="5")
optimizer_frame.grid(row=3, column=0, pady=2, sticky=(tk.W, tk.E))

pulsanti_optimizer = {
    "Adam": ttk.Button(optimizer_frame, text="Adam", command=lambda: seleziona_optimizer("Adam")),
    "RMSprop": ttk.Button(optimizer_frame, text="RMSprop", command=lambda: seleziona_optimizer("RMSprop")),
    "SGD": ttk.Button(optimizer_frame, text="SGD", command=lambda: seleziona_optimizer("SGD")),
    "Adagrad": ttk.Button(optimizer_frame, text="Adagrad", command=lambda: seleziona_optimizer("Adagrad")),
    "Adadelta": ttk.Button(optimizer_frame, text="Adadelta", command=lambda: seleziona_optimizer("Adadelta")),
    "Adamax": ttk.Button(optimizer_frame, text="Adamax", command=lambda: seleziona_optimizer("Adamax")),
    "Nadam": ttk.Button(optimizer_frame, text="Nadam", command=lambda: seleziona_optimizer("Nadam"))
}
for idx, btn in enumerate(pulsanti_optimizer.values()):
    btn.grid(row=0, column=idx, padx=2)

# --- Selezione della Funzione di Perdita ---
loss_frame = ttk.LabelFrame(main_frame, text="Seleziona la Funzione di Perdita", padding="5")
loss_frame.grid(row=3, column=1, pady=2, sticky=(tk.W, tk.E))

pulsanti_loss = {
    "mse": ttk.Button(loss_frame, text="MSE", command=lambda: seleziona_loss("mse")),
    "mae": ttk.Button(loss_frame, text="MAE", command=lambda: seleziona_loss("mae")),
    "msle": ttk.Button(loss_frame, text="MSLE", command=lambda: seleziona_loss("msle")),
    "huber": ttk.Button(loss_frame, text="Huber", command=lambda: seleziona_loss("huber")),
    "logcosh": ttk.Button(loss_frame, text="LogCosh", command=lambda: seleziona_loss("logcosh"))
}
for idx, btn in enumerate(pulsanti_loss.values()):
    btn.grid(row=0, column=idx, padx=2)

# --- Opzioni Avanzate ---
advanced_frame = ttk.LabelFrame(main_frame, text="Opzioni Avanzate", padding="5")
advanced_frame.grid(row=4, column=0, columnspan=2, pady=2, sticky=(tk.W, tk.E))

check_early_stopping = ttk.Checkbutton(advanced_frame, text="Usa Early Stopping", variable=use_early_stopping)
check_early_stopping.grid(row=0, column=0, padx=5, sticky=tk.W)

check_cross_validation = ttk.Checkbutton(advanced_frame, text="Usa Cross Validation", variable=use_cross_validation)
check_cross_validation.grid(row=0, column=1, padx=5, sticky=tk.W)

check_ensemble = ttk.Checkbutton(advanced_frame, text="Usa Ensemble", variable=use_ensemble)
check_ensemble.grid(row=1, column=0, padx=5, sticky=tk.W)

ttk.Label(advanced_frame, text="Numero di modelli nell'ensemble:").grid(row=2, column=0, padx=5, sticky=tk.W)
spinbox_num_models = ttk.Spinbox(advanced_frame, from_=1, to=10, width=5)
spinbox_num_models.grid(row=2, column=1, padx=5, sticky=tk.W)

# --- Stato e Output ---
status_bar = ttk.Label(main_frame, text="Stato: in attesa...", relief=tk.SUNKEN, anchor='w')
status_bar.grid(row=5, column=0, columnspan=2, sticky=(tk.W, tk.E))

text_output = tk.Text(main_frame, height=10, width=80)
text_output.grid(row=6, column=0, columnspan=2, padx=5, pady=5)

# --- Pulsante di Avvio ---
button_avvia = ttk.Button(main_frame, text="Avvia Previsione", command=avvia_previsione)
button_avvia.grid(row=7, column=0, columnspan=2, pady=10)

# Label ultima estrazione
ultima_estrazione_label = ttk.Label(main_frame, text=data_ultima_estrazione)
ultima_estrazione_label.grid(row=8, column=0, columnspan=2)

root.mainloop()

max63 · Venerdì alle 17:35

Bella storia Lottopython..
Ritengo sia necessario implementare con piu dati statistici.....frequenze..ritardi..quindi le tendenze. A questo punto avremo una dataset con nuove caratteristiche..poi bisogna dividere i dati in set di addestramento e fare dei test addestrando i modelli...
Si puo fare..Reti neurali piu profonde e altri algoritmi di machine learnig.Sto provando anche se al momento le risultanze sulle ruote selezionate comparando i vari ottimizatori non sono male....ma non ci siamo ancora..anche se l 'ambo su tutte nei primi colpi compare...ma non ci siamo ancora

max63 · Venerdì alle 17:38

Bisognerebbe integrare il lavoro di Tom

))

Lottopython · Venerdì alle 18:13

max63 ha scritto:
Bella storia Lottopython..
Ritengo sia necessario implementare con piu dati statistici.....frequenze..ritardi..quindi le tendenze. A questo punto avremo una dataset con nuove caratteristiche..poi bisogna dividere i dati in set di addestramento e fare dei test addestrando i modelli...
Si puo fare..Reti neurali piu profonde e altri algoritmi di machine learnig.Sto provando anche se al momento le risultanze sulle ruote selezionate comparando i vari ottimizatori non sono male....ma non ci siamo ancora..anche se l 'ambo su tutte nei primi colpi compare...ma non ci siamo ancora

max63 ha scritto:
Bisognerebbe integrare il lavoro di Tom

L'argomento introdotto da lotto_tom è interessante senza dubbio ,lo affronteremo strada facendo , al momento mi soffermerei sul comprendere meglio le funzionalità di questo codice piu che ampliare le potenzialità , capire come muoversi e dove intervenire, la leggibilità delle logiche ben suddivise è da tenere sempre come obbiettivo principale.
Una cosa voglio chiederti :
questi parametri sono automatizzati al fine di ottenere le condizioni migliori ma non è anche una limitazione ?

intendo dire: dovrebbe esserci nel programma la possibilità di flaggare se automatizzarle o no

# Valori consigliati per i parametri di addestramento
suggested_values = {
"Adam": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
"RMSprop": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
"SGD": {"epochs": 100, "batch_size": 64, "learning_rate": 0.01},
"Adagrad": {"epochs": 100, "batch_size": 64, "learning_rate": 0.01},
"Adadelta": {"epochs": 100, "batch_size": 64, "learning_rate": 1.0},
"Adamax": {"epochs": 100, "batch_size": 64, "learning_rate": 0.002},
"Nadam": {"epochs": 100, "batch_size": 64, "learning_rate": 0.002},
"mse": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
"mae": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
"msle": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
"huber": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001},
"logcosh": {"epochs": 100, "batch_size": 64, "learning_rate": 0.001}

ed è collegato a questo :

# Funzione per valutare la perdita di validazione
def valuta_val_loss(val_loss):
if val_loss < 0.05:
return "Ottimale"
elif val_loss < 0.1:
return "Discreto"
elif val_loss < 0.2:
return "Sufficiente"
else:
return "Scarso"

Python - Addestramento rete neurale

Super Member >PLATINUM<

Super member

Allegati

Super member

Allegati

Super Member >PLATINUM<

Super Member >PLATINUM<

Super member

Allegati

Junior Member

Allegati

Super Member >PLATINUM<

Junior Member

Junior Member

Allegati

Super Member >PLATINUM<

Super Member >PLATINUM<

Super member

Allegati

Advanced Premium Member

Super member

Super member

Allegati

Super Member >PLATINUM<

Super member

Super member

Super Member >PLATINUM<