Python - Addestramento rete neurale

SatuRno17 · Ieri alle 17:15

Apro questa discussione per condividere con gli appassionati di IA questo codice in python che addestra un rete neurale (tensorflow) per fare previsioni lotto.
Considerazioni importanti:
1. Il codice è stato creato con l'aiuto di chatGpt ma ho dovuto modificarlo altrimenti non funzionava correttamente.
2. Il codice elabora una previsione che per il momento non è attendibile (dalle prove fatte per adesso ha un' accuracy intorno al 20%) ma tutto si può migliorare quindi chiunque voglia modificarlo è ben accetto. Ovviamente sto cercando di modificarlo ma venendo dal basic mi trovo molto in difficoltà con questo linguaggio e perdo tanto tempo tra gli errori di scrittura.
3. Siccome c'è bisogno di un'archivio.csv, io ho provato a cercare/creare qualcosa ma per il momento sono riuscito solo ad ottenere un archivio di Bari anno 2024 che non mi fa allegare non so perchè (dimensione 6 Kb).
N.B. per eseguire il codice serve Python versione 3.10 e serve aver installato le librerie : numpy, pandas, tensorflow

Python:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

data = pd.read_csv(r"2024_BA.csv",header=None,sep=";")

# Filtra i numeri estratti
numeri = data.iloc[:, 1:6].values  # Seleziona le colonne con gli estratti

# Normalizza i numeri (ad esempio da 1-90 a 0-1)
scaler = MinMaxScaler(feature_range=(0, 1))
numeri_normalizzati = scaler.fit_transform(numeri)

# Creazione dei dati di input (X) e output (y)
X = numeri_normalizzati[:-1]  # Tutti i gruppi tranne l'ultimo
y = numeri_normalizzati[1:]   # Gruppi spostati in avanti di una riga

# Dividere i dati in train e test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 3. Creare il modello di rete neurale
model = Sequential()
model.add(Dense(128, input_dim=X.shape[1], activation="relu"))  # Primo livello
model.add(Dense(64, activation="relu"))                        # Secondo livello
model.add(Dense(X.shape[1], activation="sigmoid"))             # Livello di output

# 4. Compilare il modello
model.compile(optimizer="adam", loss="mean_squared_error", metrics=["accuracy"])

# 5. Addestrare il modello
history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test))

# 6. Valutare il modello
loss, accuracy = model.evaluate(X_test, y_test)
print(f"Loss: {loss}, accuracy: {accuracy}")

# 7. Previsione
# Prevedere il prossimo gruppo di numeri (esempio)
next_prediction = model.predict(X_test[:1])  # Usa il primo elemento del test set
numeri_originali = scaler.inverse_transform(next_prediction)  # Riconverti i numeri al range originale
numeri_interi = numeri_originali.round().astype(int)
print("Prossima previsione:", numeri_interi[0])

Lottopython · Ieri alle 17:47

ciao
ho provato a modificarlo solo per far in modo che leggesse i miei file in txt aggiornabili con un piccolo programma fatto da me per le estrazioni

ti allego un img vediamo

SatuRno17 · Ieri alle 18:00

Bravissimo Lottopython, sono contento che il codice funzioni anche con file text. Complimenti!

Ora bisogna perfezionarlo

Lottopython · Ieri alle 18:03

si sto facendo delle verifiche sommarie poi ti giro il codice con le ruote e il programmino per aggiornare i file ruote semplicemente impostando le nuove data da: a:

Lottopython · Ieri alle 18:04

poi è semplice puoi fare un programma in base alle necessità per crearti un file estrazionale

Lottopython · Ieri alle 18:10

è una prima bozza da verificare correggere e impostare meglio ,il formato ruote è YYYY/MM/DD il programmino per l'aggiornamento è davvero semplice scarica lo storico lo scompatta e aggiorna le ruote in un colpo solo , attenzione solo alla ruota nazionale che va rinominata da RN A NZ tutto qui.

Lottopython · Ieri alle 18:10

per quello che posso ci sono

SatuRno17 · Ieri alle 18:12

Si sto provando a scrivere qualcosa ma purtroppo sono troppo legato al basic e faccio parecchi errori di sintassi
Tipo

Codice:

Basic :
a <> b ' a diverso da b

Python :
a != b # a diverso da b

SatuRno17 · Ieri alle 18:14

Lottopython ha scritto:
è una prima bozza da verificare correggere e impostare meglio ,il formato ruote è YYYY/MM/DD il programmino per l'aggiornamento è davvero semplice scarica lo storico lo scompatta e aggiorna le ruote in un colpo solo , attenzione solo alla ruota nazionale che va rinominata da RN A NZ tutto qui.

Ti ringrazio molto Lottopython.

Lottopython · Ieri alle 18:18

in questo ho inserito un piccolo box txt per i risultati
niente di che ma prima è necessario verificare il codice e i risultati che credo vada un po rivisto

Codice:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import tkinter as tk
from tkinter import messagebox, scrolledtext

# Definizione dei file delle ruote
file_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',
    'TO': 'Torino.txt',
    'VE': 'Venezia.txt',
    'NZ': 'Nazionale.txt'
}

# Funzione per caricare i dati della ruota selezionata
def carica_dati(ruota):
    file_name = file_ruote[ruota]
    try:
        # Usa il separatore di tabulazione per leggere il file
        data = pd.read_csv(file_name, header=None, sep="\t")
        print(f"File caricato: {file_name}")

        # Seleziona solo i numeri (dalla terza colonna in poi)
        numeri = data.iloc[:, 2:].values

        if numeri.size == 0:
            print("Nessun numero trovato nel file.")
            return None, None, None

        # Normalizza i numeri
        scaler = MinMaxScaler(feature_range=(0, 1))
        numeri_normalizzati = scaler.fit_transform(numeri.astype(float))

        X = numeri_normalizzati[:-1]  # Tutti i numeri tranne l'ultimo
        y = numeri_normalizzati[1:]    # Tutti i numeri a partire dal secondo

        return X, y, scaler
    except Exception as e:
        print(f"Errore durante il caricamento dei dati: {e}")
        return None, None, None

# Funzione per gestire la selezione della ruota
def on_seleziona_ruota(ruota):
    X, y, scaler = carica_dati(ruota)
    
    if X is not None and y is not None:
        print(f"Dimensione X: {X.shape}, Dimensione y: {y.shape}")

        # Dividere i dati in train e test
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

        # Creare il modello di rete neurale
        model = Sequential()
        model.add(Dense(128, input_shape=(X.shape[1],), activation="relu"))
        model.add(Dense(64, activation="relu"))
        model.add(Dense(X.shape[1], activation="sigmoid"))

        # Compilare il modello
        model.compile(optimizer="adam", loss="mean_squared_error", metrics=["accuracy"])

        # Addestrare il modello
        model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test))

        # Previsione dei numeri
        next_prediction = model.predict(X_test[:1])
        numeri_originali = scaler.inverse_transform(next_prediction)
        numeri_interi = numeri_originali.round().astype(int)

        # Visualizza i numeri previsti e la ruota
        risultato = f"Nella ruota {ruota}, i numeri previsti sono:\n" + ", ".join(map(str, numeri_interi[0]))
        print(risultato)
        mostra_risultati(risultato)
    else:
        print("Impossibile addestrare il modello. Verifica i dati caricati.")

# Funzione di visualizzazione dei risultati
def mostra_risultati(risultato):
    text_area.delete(1.0, tk.END)  # Pulisci il box di testo
    text_area.insert(tk.END, risultato)  # Inserisci il risultato

# Funzione per esportare i numeri in un file
def esporta_numeri(numeri):
    try:
        with open("numeri_previsti.txt", "w") as file:
            file.write("Prossimi numeri da giocare:\n")
            file.write(", ".join(map(str, numeri[0])) + "\n")
        messagebox.showinfo("Esportazione completata", "Numeri esportati in numeri_previsti.txt")
    except Exception as e:
        messagebox.showerror("Errore", f"Errore durante l'esportazione: {e}")

# Creazione della finestra di selezione della ruota
root = tk.Tk()
root.title("Seleziona Ruota")

# Creazione dei pulsanti per la selezione delle ruote
for ruota in file_ruote.keys():
    btn = tk.Button(root, text=ruota, command=lambda r=ruota: on_seleziona_ruota(r))
    btn.pack(pady=5)

# Creazione di un box di testo per visualizzare i risultati
text_area = scrolledtext.ScrolledText(root, width=50, height=10)
text_area.pack(pady=10)

# Aggiungi un pulsante per esportare i numeri previsti
btn_export = tk.Button(root, text="Esporta Numeri", command=lambda: esporta_numeri(numeri_interi))
btn_export.pack(pady=5)

root.mainloop()

Lottopython · Ieri alle 18:22

SatuRno17 ha scritto:
Ti ringrazio molto Lottopython.

solo per chiarezza ripeto rimane da rivedere secondo me ..

SatuRno17 · Ieri alle 18:26

Lottopython ha scritto:

in questo ho inserito un piccolo box txt per i risultati
niente di che ma prima è necessario verificare il codice e i risultati che credo vada un po rivisto

Codice:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import tkinter as tk
from tkinter import messagebox, scrolledtext

# Definizione dei file delle ruote
file_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',
    'TO': 'Torino.txt',
    'VE': 'Venezia.txt',
    'NZ': 'Nazionale.txt'
}

# Funzione per caricare i dati della ruota selezionata
def carica_dati(ruota):
    file_name = file_ruote[ruota]
    try:
        # Usa il separatore di tabulazione per leggere il file
        data = pd.read_csv(file_name, header=None, sep="\t")
        print(f"File caricato: {file_name}")

        # Seleziona solo i numeri (dalla terza colonna in poi)
        numeri = data.iloc[:, 2:].values

        if numeri.size == 0:
            print("Nessun numero trovato nel file.")
            return None, None, None

        # Normalizza i numeri
        scaler = MinMaxScaler(feature_range=(0, 1))
        numeri_normalizzati = scaler.fit_transform(numeri.astype(float))

        X = numeri_normalizzati[:-1]  # Tutti i numeri tranne l'ultimo
        y = numeri_normalizzati[1:]    # Tutti i numeri a partire dal secondo

        return X, y, scaler
    except Exception as e:
        print(f"Errore durante il caricamento dei dati: {e}")
        return None, None, None

# Funzione per gestire la selezione della ruota
def on_seleziona_ruota(ruota):
    X, y, scaler = carica_dati(ruota)
   
    if X is not None and y is not None:
        print(f"Dimensione X: {X.shape}, Dimensione y: {y.shape}")

        # Dividere i dati in train e test
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

        # Creare il modello di rete neurale
        model = Sequential()
        model.add(Dense(128, input_shape=(X.shape[1],), activation="relu"))
        model.add(Dense(64, activation="relu"))
        model.add(Dense(X.shape[1], activation="sigmoid"))

        # Compilare il modello
        model.compile(optimizer="adam", loss="mean_squared_error", metrics=["accuracy"])

        # Addestrare il modello
        model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test))

        # Previsione dei numeri
        next_prediction = model.predict(X_test[:1])
        numeri_originali = scaler.inverse_transform(next_prediction)
        numeri_interi = numeri_originali.round().astype(int)

        # Visualizza i numeri previsti e la ruota
        risultato = f"Nella ruota {ruota}, i numeri previsti sono:\n" + ", ".join(map(str, numeri_interi[0]))
        print(risultato)
        mostra_risultati(risultato)
    else:
        print("Impossibile addestrare il modello. Verifica i dati caricati.")

# Funzione di visualizzazione dei risultati
def mostra_risultati(risultato):
    text_area.delete(1.0, tk.END)  # Pulisci il box di testo
    text_area.insert(tk.END, risultato)  # Inserisci il risultato

# Funzione per esportare i numeri in un file
def esporta_numeri(numeri):
    try:
        with open("numeri_previsti.txt", "w") as file:
            file.write("Prossimi numeri da giocare:\n")
            file.write(", ".join(map(str, numeri[0])) + "\n")
        messagebox.showinfo("Esportazione completata", "Numeri esportati in numeri_previsti.txt")
    except Exception as e:
        messagebox.showerror("Errore", f"Errore durante l'esportazione: {e}")

# Creazione della finestra di selezione della ruota
root = tk.Tk()
root.title("Seleziona Ruota")

# Creazione dei pulsanti per la selezione delle ruote
for ruota in file_ruote.keys():
    btn = tk.Button(root, text=ruota, command=lambda r=ruota: on_seleziona_ruota(r))
    btn.pack(pady=5)

# Creazione di un box di testo per visualizzare i risultati
text_area = scrolledtext.ScrolledText(root, width=50, height=10)
text_area.pack(pady=10)

# Aggiungi un pulsante per esportare i numeri previsti
btn_export = tk.Button(root, text="Esporta Numeri", command=lambda: esporta_numeri(numeri_interi))
btn_export.pack(pady=5)

root.mainloop()

Mi ci vorrà un bel pò di tempo per capirlo, comunque ti ringrazio ancora

Lottopython · Ieri alle 18:28

utilizza al meglio L'IA ti darà un gran supporto e di pari passo impari piu velocemente non che io sia una cima eh sia chiaro ,in confronto ai mostri sacri qui sono agli inizi

lotto_tom75 · Ieri alle 21:52

SatuRno17 · Oggi alle 12:32

Un primo passo per modificare il codice sta nel cambiare il modo dell'addestramento della rete.

Python:

# Creazione dei dati di input (X) e output (y)
X = numeri_normalizzati[:-1]  # Tutti i gruppi tranne l'ultimo
y = numeri_normalizzati[1:]   # Gruppi spostati in avanti di una riga

In questo caso la rete riceve come input (X) i numeri delle estrazioni tranne l'ultima e legge come output (Y) i numeri delle estrazioni successive a quelle dell'input (X). Quindi si addestra facendo previsioni tra estrazione precedente e successiva.
Giocando con i vari Array si possono fare migliaia di prove...ad esempio io ho provato a mettere in input 3 estrazioni e in base a quelle prevedere la successiva (la quarta).. si potrebbe ad esempio mettere in output diverse estrazioni (cioè come se giocassimo con più colpi ). Insomma ci si può sbizzarrire in tutti i modi e magari chissà si può trovare una accuratezza migliore.

Lottopython · Oggi alle 15:52

beta 2 (da verifica la correttezza)
si accettano critiche costruttive e nuove elaborazioni o implementazioni
tanto da fare per chi volesse partecipare

codice gratuito nessuna vendita o si forniscono previsioni alcune

Codice:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
import tkinter as tk
from tkinter import messagebox, scrolledtext
from tkinter import ttk

# Definizione dei file delle ruote
file_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',
    'TO': 'Torino.txt',
    'VE': 'Venezia.txt',
    'NZ': 'Nazionale.txt'
}

# Funzione per caricare i dati della ruota selezionata
def carica_dati(ruota, num_estrazioni):
    """Carica i dati della ruota selezionata e prepara X e y."""
    file_name = file_ruote[ruota]
    try:
        data = pd.read_csv(file_name, header=None, sep="\t")
        mostra_risultati(f"File caricato: {file_name}\n")

        numeri = data.iloc[:, 2:].values  # Supponendo che i numeri inizino dalla terza colonna

        if numeri.size == 0:
            mostra_risultati("Nessun numero trovato nel file.\n")
            return None, None, None

        scaler = MinMaxScaler(feature_range=(0, 1))
        numeri_normalizzati = scaler.fit_transform(numeri.astype(float))

        X, y = [], []
        for i in range(len(numeri_normalizzati) - num_estrazioni):
            X.append(numeri_normalizzati[i:i + num_estrazioni])  # Forma (num_estrazioni, num_features)
            y.append(numeri_normalizzati[i + num_estrazioni])     # Forma (num_features)

        X = np.array(X)  # Forma ora (num_samples, num_estrazioni, num_features)
        y = np.array(y)

        mostra_risultati(f"Dimensione X: {X.shape}, Dimensione y: {y.shape}\n")
        
        return X, y, scaler
    except Exception as e:
        mostra_risultati(f"Errore durante il caricamento dei dati: {e}\n")
        return None, None, None

# Funzione per creare e addestrare il modello
def crea_modello(X_train, y_train):
    """Crea e addestra un modello."""
    mostra_risultati("Creazione del modello...\n")
    model = Sequential()

    # Appiattire l'input se X_train è tridimensionale
    if len(X_train.shape) == 3:
        model.add(Flatten(input_shape=(X_train.shape[1], X_train.shape[2])))  # Appiattire l'input
    else:
        model.add(Dense(128, activation="relu", input_shape=(X_train.shape[1],)))
    
    model.add(Dense(128, activation="relu"))
    model.add(Dropout(0.2))  # Aggiunta del dropout per prevenire l'overfitting
    model.add(Dense(64, activation="relu"))
    model.add(Dropout(0.2))
    
    model.add(Dense(y_train.shape[1], activation="sigmoid"))  # Output deve avere la stessa dimensione di y

    model.compile(optimizer="adam", loss="mean_squared_error", metrics=["accuracy"])
    mostra_risultati("Modello creato e compilato con successo.\n")
    return model

# Funzione per gestire la selezione della ruota
def on_seleziona_ruota(ruota):
    global numeri_previsti  # Rendi la variabile globale per l'export
    try:
        num_estrazioni = int(entry_num_estrazioni.get())
        if num_estrazioni < 1:
            mostra_risultati("Il numero di estrazioni deve essere maggiore di zero.\n")
            return
    except ValueError:
        mostra_risultati("Inserisci un numero valido per le estrazioni.\n")
        return

    X, y, scaler = carica_dati(ruota, num_estrazioni)

    if X is not None and y is not None:
        try:
            epochs = int(entry_epochs.get())
            mostra_risultati(f"Inizio training del modello per {epochs} epoche...\n")
        except ValueError:
            mostra_risultati("Inserisci un numero valido per gli epochs.\n")
            return

        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
        model = crea_modello(X_train, y_train)  # Passa y_train nel modello

        # Callback per visualizzare i messaggi durante l'addestramento
        class PrintEpochs(tf.keras.callbacks.Callback):
            def on_epoch_end(self, epoch, logs):
                msg = f"Epoch {epoch + 1}/{epochs} - loss: {logs['loss']:.4f} - val_loss: {logs['val_loss']:.4f}\n"
                mostra_risultati(msg)

        # Training del modello
        model.fit(X_train, y_train, epochs=epochs, batch_size=32,
                  validation_data=(X_test, y_test), callbacks=[PrintEpochs()])

        # Previsione
        next_prediction = model.predict(X_test[:1])
        numeri_originali = scaler.inverse_transform(next_prediction)
        numeri_interi = numeri_originali.round().astype(int)

        risultato = f"Nella ruota {ruota}, i numeri previsti sono:\n{', '.join(map(str, numeri_interi[0]))}\n"
        mostra_risultati(risultato)

        numeri_previsti = numeri_interi.tolist()  # Salva i numeri previsti per l'export
        return numeri_interi
    else:
        mostra_risultati("Impossibile addestrare il modello. Verifica i dati caricati.\n")
        return None

# Funzione di visualizzazione dei risultati
def mostra_risultati(risultato):
    """Visualizza un risultato all'utente."""
    text_area.insert(tk.END, risultato)  # Includi il risultato nel box di testo
    text_area.configure(fg='lime', bg='black')  # Colore del testo e sfondo
    text_area.see(tk.END)  # Scorri verso il basso per mostrare l'ultimo risultato

# Funzione per esportare i numeri in un file
def esporta_numeri(numeri):
    """Esporta i numeri previsti in un file."""
    if numeri is not None:
        try:
            with open("numeri_previsti.txt", "w") as file:
                file.write("Prossimi numeri da giocare:\n")
                file.write(", ".join(map(str, numeri[0])) + "\n")
            messagebox.showinfo("Esportazione completata", "Numeri esportati in numeri_previsti.txt")
        except Exception as e:
            messagebox.showerror("Errore", f"Errore durante l'esportazione: {e}")
    else:
        messagebox.showerror("Errore", "Nessun numero previsto da esportare.")

# Creazione della finestra principale
root = tk.Tk()
root.title("Previsione Numeri Ruote")
root.geometry("1200x900")  # Imposta la dimensione della finestra

# Creazione di un titolo
title = tk.Label(root, text="LottoSaturno beta3", font=('Helvetica', 24, 'bold'), bg='#e0f7fa')
title.pack(pady=10, fill='x')  # Aggiungi un padding e riempiscilo orizzontalmente

# Creazione di un frame per i pulsanti di selezione della ruota
button_frame = tk.Frame(root, bg='#e0f7fa')
button_frame.pack(pady=10)

for ruota in file_ruote.keys():
    btn = ttk.Button(button_frame, text=ruota,
                     command=lambda r=ruota: on_seleziona_ruota(r))
    btn.pack(side=tk.LEFT, padx=5)

# Creazione di un frame per l'input numero di estrazioni
input_frame = tk.Frame(root, bg='#e0f7fa')
input_frame.pack(pady=10)

label_num_estrazioni = tk.Label(input_frame, text="Inserisci il numero di estrazioni da usare:", bg='#e0f7fa')
label_num_estrazioni.pack(side=tk.LEFT)
entry_num_estrazioni = tk.Entry(input_frame)
entry_num_estrazioni.pack(side=tk.LEFT, padx=5)

# Creazione di un frame per l'input numero di epoch
input_frame_epochs = tk.Frame(root, bg='#e0f7fa')
input_frame_epochs.pack(pady=10)

label_epochs = tk.Label(input_frame_epochs, text="Inserisci il numero di epoch:", bg='#e0f7fa')
label_epochs.pack(side=tk.LEFT)
entry_epochs = tk.Entry(input_frame_epochs)
entry_epochs.pack(side=tk.LEFT, padx=5)

# Creazione di un box di testo per visualizzare i risultati
text_area = scrolledtext.ScrolledText(root, width=80, height=20, wrap=tk.WORD, bg='black', fg='lime', font=('Arial', 12))
text_area.pack(pady=10, fill='x', expand=True)  # Aggiungi un padding, riempi orizzontalmente e espanda verticalmente

# Aggiungi un pulsante per esportare i numeri previsti
btn_export = ttk.Button(root, text="Esporta Numeri",
                         command=lambda: esporta_numeri(numeri_previsti))
btn_export.pack(pady=10)

# Aggiungi un footer
footer = tk.Label(root, text="SatuRno17", font=('Helvetica', 10, 'italic'), bg='#e0f7fa')
footer.pack(side='bottom', pady=10)

# Variabile globale per i numeri previsti
numeri_previsti = None

# Avvio della GUI
root.mainloop()

SatuRno17 · Oggi alle 16:27

Sei riuscito a creare una sorta di programma, sei proprio bravo @Lottopython , ora capisco perché ti chiami così

. Io mi confondo ancora con la libreria Tkinter. Comunque complimenti per questo lavoro

e speriamo che possa essere utile magari per qualche convergenza.

Lottopython · Oggi alle 16:39

SatuRno17 ha scritto:
Sei riuscito a creare una sorta di programma, sei proprio bravo @Lottopython , ora capisco perché ti chiami così . Io mi confondo ancora con la libreria Tkinter. Comunque complimenti per questo lavoro e speriamo che possa essere utile magari per qualche convergenza.

è un tentativo pensa che lo faccio mentre sono in attesa ,mezza pausa , ma lo faccio dando indicazioni all'IA la mia IA , cmq. sia i bravi e competenti sono altri io sono un semplice appassionato null'altro ,@lotto_tom75 è il top in questo ma credo abbia il suo da fare
poi mettere mano nei progetti altrui credo che interessi poco ,l'impostazione di un codice va gestita fin dall'inizio a proprio modo e venirne a capo è sempre cosa ardua . Detto questo vediamo cosa si puo' migliorare l'idea mi stuzzica ,,,se solo potessi farlo per lavoro

.

Lottopython · Oggi alle 16:43

puoi farlo anche tu questa è la mia IA di fiducia ia di fiducia sfiduciata

SatuRno17 · Oggi alle 17:12

Lottopython ha scritto:
puoi farlo anche tu questa è la mia IA di fiducia ia di fiducia sfiduciata

Non conosco questa IA, la devo provare . Grazie

Python - Addestramento rete neurale

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Allegati

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Advanced Premium Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member

Senior Member