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()
Ora bisogna perfezionarlo 
.
