chatgpt python e lotto

[andy881]

Hai qualche previsione x stasera ?

 

[lotto_tom75]

Hai qualche previsione x stasera ?

Motore di ricerca interno al forum e good luck! (odio fare da balia...)

 

[lotto_tom75]

Riporto per condivisione e tipo backup online alcuni script python realizzati con chatgpt per cercare di implementare vari sistemi di ricerca, analisi e riduzione predittiva di tipo neurale al fine di poterli anche ottimizzare per uno o più aspetti collaborando tutti insieme...

Analisi con modello ARIMA e ricerca configurazione dei suoi parametri ottimali mediante controllo con RQUADRO. Questa versione analizza un file con i numeri degli estratti o dei soli sfaldati con gli eventualmente non usciti sostituiti da 00 e con le righe ordinate con i numeri in ordine crescente d a sx a dx con un formato di questo tipo:

Indice,Estratti
1,15.18.71.81.00
2,42.46.60.79.00
3,28.29.41.74.00
4,17.46.59.72.00
5,11.15.19.73.85
6,11.23.41.71.00
7,62.84.85.00.00
8,19.20.65.66.00
9,38.43.50.52.68
...

# by lotto_tom75 & chatgpt

import pandas as pd
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import r2_score
import math
import time
import logging


# Inizio del tempo di elaborazione
start_time = time.time()

# Imposta il logger di Python per ignorare i messaggi di avviso
logging.getLogger().setLevel(logging.ERROR)

import warnings

# Ignora tutti i messaggi di avviso
warnings.filterwarnings("ignore")

# Inizio del tempo di elaborazione
start_time = time.time()

print("Elaborazione in corso...")

# Carica i dati estratti dal file CSV, specificando il tipo di dati delle colonne
data = pd.read_csv('sfaldamenti-gruppobase-ordinamento-usciti-da-sx-a-dx.txt', dtype={'Indice': int, 'Estratti': str})

# Prepara i dati per l'analisi
# Converti la colonna degli estratti in una lista di interi
estratti = []
data['Estratti'].apply(lambda x: estratti.extend(map(int, x.split('.'))))

# Definisci una funzione per calcolare R quadro
def compute_r_squared(ground_truth, predictions):
    return r2_score(ground_truth, predictions)

# Funzione per fare previsioni utilizzando il modello ARIMA ottimale
def make_prediction(serie_temporale, order):
    # Costruisci il modello ARIMA utilizzando i parametri ottimali
    model = ARIMA(serie_temporale, order=order)
    model_fit = model.fit()

    # Fai previsioni sul set di dati
    predictions = model_fit.forecast(steps=5)  # Cambia steps a 10 se vuoi 10 predizioni
    return predictions

# Imposta il valore di R quadro desiderato per interrompere l'analisi
target_r_squared = 0.75  # Valore massimo teorico di R quadro con le ultime 3 estrazioni

# Imposta il numero iniziale di ultime estrazioni da considerare
num_ultime_estr = 9  # Considera solo le ultime 3 estrazioni inizialmente

# Trova i parametri ARIMA ottimali
best_r_squared = -float('inf')
best_order = None
best_predictions = None

#while best_r_squared < target_r_squared:
while num_ultime_estr > 0 and best_r_squared < target_r_squared:
    # Resto del codice...

    print(f"Analisi delle ultime {num_ultime_estr} estrazioni...")
    estratti_temp = estratti[-num_ultime_estr:]

    for p in range(11):  # Prova valori per p da 0 a 10
        for d in range(3):  # Prova valori per d da 0 a 2
            for q in range(3):  # Prova valori per q da 0 a 2
                # Costruisci il modello ARIMA
                model = ARIMA(estratti_temp, order=(p, d, q))
                try:
                    model_fit = model.fit()
                    # Fai predizioni sul set di dati
                    predictions = model_fit.predict()

                    # Calcola R quadro
                    r_squared = compute_r_squared(estratti_temp, predictions)

                    # Aggiorna i parametri se R quadro è migliorato
                    if r_squared > best_r_squared:
                        best_r_squared = r_squared
                        best_order = (p, d, q)
                        best_predictions = predictions
                        print(f"Parametri ARIMA ottimali aggiornati: {best_order}, R quadro massimo trovato: {best_r_squared}")
                except:
                    continue

    # Stampa il risultato corrente
    print("Parametri ARIMA ottimali:", best_order)
    print("R quadro massimo trovato:", best_r_squared)

    # Fai previsioni utilizzando i parametri ARIMA ottimali
    predictions = make_prediction(estratti, best_order)
    print("Previste per i prossimi 5/10 estratti:", predictions)

    # Funzione per arrotondare in base alla parte decimale
    def arrotonda_misto(numero):
        parte_intera = int(numero)
        parte_decimale = numero - parte_intera
        if parte_decimale >= 0.5:
            return math.ceil(numero)
        else:
            return math.floor(numero)

    # Stampare i numeri arrotondati per eccesso, per difetto e "mixati"
    print("Numeri arrotondati per eccesso:")
    for previsione in predictions:
        print(math.ceil(previsione), end=" ")
    print("\n")

    print("Numeri arrotondati per difetto:")
    for previsione in predictions:
        print(math.floor(previsione), end=" ")
    print("\n")

    print("Numeri arrotondati in base alla parte decimale:")
    for previsione in predictions:
        print(arrotonda_misto(previsione), end=" ")
    print("\n")

    # Aumenta il numero di ultime estrazioni da considerare solo se non si è raggiunto il valore massimo di R quadro
    if best_r_squared < target_r_squared:
        num_ultime_estr -= 1

# Fine del tempo di elaborazione
end_time = time.time()

# Calcolare il tempo impiegato
elapsed_time = end_time - start_time

# Stampare il tempo impiegato
print("Tempo impiegato per l'elaborazione:", round(elapsed_time, 2), "secondi")

Analisi con modello ARIMA e ricerca configurazione dei suoi parametri ottimali mediante controllo con RQUADRO. Questa versione analizza un file con i numeri degli estratti o dei soli sfaldati con gli eventualmente non usciti sostituiti da 00 e con le righe che mantengono le esatte posizioni di uscita presenti nell'archivio estrazioni esaminato con questo formato (seguendo lo stesso esempio sopra).

Indice,Estratti
1,15.71.18.00.81
2,79.60.46.00.42
3,29.74.08.41.28
4,00.72.17.46.59
5,11.15.19.73.85
6,41.11.71.23.00
7,62.85.00.84.00
8,66.65.00.20.19
9,50.43.68.38.52
...

# by lotto_tom75 & chatgpt

import pandas as pd
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import r2_score
import math
import time
import logging


# Inizio del tempo di elaborazione
start_time = time.time()

# Imposta il logger di Python per ignorare i messaggi di avviso
logging.getLogger().setLevel(logging.ERROR)

import warnings

# Ignora tutti i messaggi di avviso
warnings.filterwarnings("ignore")

# Inizio del tempo di elaborazione
start_time = time.time()

print("Elaborazione in corso...")

# Carica i dati estratti dal file CSV, specificando il tipo di dati delle colonne
data = pd.read_csv('sfaldamenti-gruppobase-ordinamento-usciti-posizioni-reali.txt', dtype={'Indice': int, 'Estratti': str})

# Prepara i dati per l'analisi
# Converti la colonna degli estratti in una lista di interi
estratti = []
data['Estratti'].apply(lambda x: estratti.extend(map(int, x.split('.'))))

# Definisci una funzione per calcolare R quadro
def compute_r_squared(ground_truth, predictions):
    return r2_score(ground_truth, predictions)

# Funzione per fare previsioni utilizzando il modello ARIMA ottimale
def make_prediction(serie_temporale, order):
    # Costruisci il modello ARIMA utilizzando i parametri ottimali
    model = ARIMA(serie_temporale, order=order)
    model_fit = model.fit()

    # Fai previsioni sul set di dati
    predictions = model_fit.forecast(steps=5)  # Cambia steps a 10 se vuoi 10 predizioni
    return predictions

# Imposta il valore di R quadro desiderato per interrompere l'analisi
target_r_squared = 0.75  # Valore massimo teorico di R quadro con le ultime 3 estrazioni

# Imposta il numero iniziale di ultime estrazioni da considerare
num_ultime_estr = 9  # Considera solo le ultime 3 estrazioni inizialmente

# Trova i parametri ARIMA ottimali
best_r_squared = -float('inf')
best_order = None
best_predictions = None

#while best_r_squared < target_r_squared:
while num_ultime_estr > 0 and best_r_squared < target_r_squared:
    # Resto del codice...

    print(f"Analisi delle ultime {num_ultime_estr} estrazioni...")
    estratti_temp = estratti[-num_ultime_estr:]

    for p in range(11):  # Prova valori per p da 0 a 10
        for d in range(3):  # Prova valori per d da 0 a 2
            for q in range(3):  # Prova valori per q da 0 a 2
                # Costruisci il modello ARIMA
                model = ARIMA(estratti_temp, order=(p, d, q))
                try:
                    model_fit = model.fit()
                    # Fai predizioni sul set di dati
                    predictions = model_fit.predict()

                    # Calcola R quadro
                    r_squared = compute_r_squared(estratti_temp, predictions)

                    # Aggiorna i parametri se R quadro è migliorato
                    if r_squared > best_r_squared:
                        best_r_squared = r_squared
                        best_order = (p, d, q)
                        best_predictions = predictions
                        print(f"Parametri ARIMA ottimali aggiornati: {best_order}, R quadro massimo trovato: {best_r_squared}")
                except:
                    continue

    # Stampa il risultato corrente
    print("Parametri ARIMA ottimali:", best_order)
    print("R quadro massimo trovato:", best_r_squared)

    # Fai previsioni utilizzando i parametri ARIMA ottimali
    predictions = make_prediction(estratti, best_order)
    print("Previste per i prossimi 5/10 estratti:", predictions)

    # Funzione per arrotondare in base alla parte decimale
    def arrotonda_misto(numero):
        parte_intera = int(numero)
        parte_decimale = numero - parte_intera
        if parte_decimale >= 0.5:
            return math.ceil(numero)
        else:
            return math.floor(numero)

    # Stampare i numeri arrotondati per eccesso, per difetto e "mixati"
    print("Numeri arrotondati per eccesso:")
    for previsione in predictions:
        print(math.ceil(previsione), end=" ")
    print("\n")

    print("Numeri arrotondati per difetto:")
    for previsione in predictions:
        print(math.floor(previsione), end=" ")
    print("\n")

    print("Numeri arrotondati in base alla parte decimale:")
    for previsione in predictions:
        print(arrotonda_misto(previsione), end=" ")
    print("\n")

    # Aumenta il numero di ultime estrazioni da considerare solo se non si è raggiunto il valore massimo di R quadro
    if best_r_squared < target_r_squared:
        num_ultime_estr -= 1

# Fine del tempo di elaborazione
end_time = time.time()

# Calcolare il tempo impiegato
elapsed_time = end_time - start_time

# Stampare il tempo impiegato
print("Tempo impiegato per l'elaborazione:", round(elapsed_time, 2), "secondi")

Analisi con modello RNN e ricerca configurazione dei suoi parametri ottimali mediante controllo con RQUADRO e altri sistemi di ottimizzazione dello stesso. Questa versione analizza un file con i numeri degli estratti o dei soli sfaldati con gli eventualmente non usciti sostituiti da 00 e con le righe che mantengono le esatte posizioni di uscita presenti nell'archivio estrazioni esaminato con questo formato (seguendo lo stesso esempio sopra). Come output oltre a generare i numeri a video genera anche un realtivo grafico a barre evidenziando in arancione il teorico e ipotetico numero in uscita.

# by lotto_tom75 & chatgpt

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import LSTM, Dense

# Carica i dati estratti dal file CSV
data = pd.read_csv('sfaldamenti-gruppobase-ordinamento-usciti-posizioni-reali.txt', dtype={'Indice': int, 'Estratti': str})

# Seleziona solo le ultime 100 righe
ultime_righe = data.tail(100)

# Prepara i dati per l'analisi
# Converti la colonna degli estratti in una lista di interi
estratti = []
ultime_righe['Estratti'].apply(lambda x: estratti.extend(map(int, x.split('.'))))

# Normalizza i dati
scaler = MinMaxScaler(feature_range=(0, 1))
estratti_normalized = scaler.fit_transform(np.array(estratti).reshape(-1, 1))

# Crea le sequenze di input e output per il modello RNN
def create_sequences(data, seq_length):
    X, y = [], []
    for i in range(len(data)-seq_length):
        X.append(data[i:i+seq_length])
        y.append(data[i+seq_length])
    return np.array(X), np.array(y)

# Definisci la lunghezza della sequenza di input
seq_length = 10

# Crea le sequenze di input e output
X, y = create_sequences(estratti_normalized, seq_length)

# Dividi i dati in set di addestramento e set di test
train_size = int(len(X) * 0.8)
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

# Definisci il modello RNN
model = Sequential([
    LSTM(50, activation='relu', input_shape=(seq_length, 1)),
    Dense(1)
])
model.compile(optimizer='adam', loss='mean_squared_error')

# Addestra il modello
model.fit(X_train, y_train, epochs=100, batch_size=32, verbose=1)

# Valuta il modello
train_loss = model.evaluate(X_train, y_train, verbose=0)
test_loss = model.evaluate(X_test, y_test, verbose=0)
print(f'Train Loss: {train_loss:.4f}')
print(f'Test Loss: {test_loss:.4f}')

# Effettua previsioni utilizzando il modello addestrato
predictions = model.predict(X_test)

# Denormalizza le previsioni
predictions = scaler.inverse_transform(predictions)
y_test_denormalized = scaler.inverse_transform(y_test)

# Visualizza i risultati
plt.plot(y_test_denormalized, label='True')
plt.plot(predictions, label='Predicted')
plt.legend()
plt.show()

# Visualizza i risultati testuali
print("Numeri predetti:")
for predetto in predictions:
    print(round(predetto[0]))

es. di output grafico generato dallo script soprastante analizzando tutte le 10k e oltre righe di sfaldamenti della 77abs x A su FI dal 1871.


es. di output grafico generato dallo script soprastante analizzando solo le ultime 100 righe di sfaldamenti della 77abs x A su FI dal 1871.



i files py per generare in un colpo solo gli archivi delle estrazioni o degli sfaldamenti per i gruppi base voluti "intepretabili dalle AI py sopra descritte a partire dal file di archivio estrazioni e da quello del gruppo base voluto li trovate qui in questo altro thread.


Adesso mi piacerebbe provare a realizzare in py grazie a chatgpt o altra AI qualcosa che assomigli a NNCLUST a GMDH e a PYTHIA

Se qualcuno ci ruscirà o se ci arriverà prima.. non faccia il trex... e me lo faccia sapere... Thanks

 

[lotto_tom75]

Aggiungo questo code python per generare 5 colonne con numeri convergenti rispettivi delle 5 colonne degli estratti per la ruota o le ruote volute con un gruppo base voluto... (es. abs ecc..)

def convergent_numbers(extracted_numbers, base_group):
    convergent_nums = []
    for number_set in extracted_numbers:
        numbers = number_set.strip().split('.')
        convergent = [num for num in numbers if num in base_group]
        if convergent:  # Aggiungi solo se ci sono numeri convergenti
            convergent_nums.append(convergent)
    return convergent_nums

def write_convergent_numbers(file_path, column_number, convergent_nums):
    with open(file_path, 'w') as file:
        file.write(f'Numero{column_number}\n')
        for numbers in convergent_nums:
            file.write(''.join(numbers) + '\n')


def main():
    extracted_file = 'estratti.txt'
    base_group_file = 'gruppo-base.txt'

    with open(extracted_file, 'r') as file:
        extracted_numbers = file.readlines()

    with open(base_group_file, 'r') as file:
        base_group = set(file.read().strip().split('.'))

    # Calcola il numero massimo di numeri convergenti in una colonna
    max_convergent_count = max(len(convergent_numbers(column.split('.'), base_group)) for column in extracted_numbers)

    for i in range(max_convergent_count):
        convergent_nums = convergent_numbers(extracted_numbers, base_group)
        output_file = f'Numero{i+1}.txt'
        write_convergent_numbers(output_file, i+1, [nums[i] for nums in convergent_nums if len(nums) > i])

if __name__ == "__main__":
    main()

estratti.txt

deve avere un formato di questo tipo:

15.71.18.64.81
79.60.46.76.42
29.74.08.41.28
22.72.17.46.59
11.15.19.73.85
41.11.71.23.31
62.85.31.84.02
66.65.86.20.19
50.43.68.38.52
90.25.76.34.47
46.19.42.82.02
88.26.17.49.41
66.72.12.10.06
26.14.78.27.57
86.75.78.05.65
35.08.88.31.53
26.45.12.35.43
70.25.08.90.67
13.64.08.16.62
06.08.50.01.77
...

mentre

gruppo-base.txt

ha questo formato:

01.03.04.05.06.07.08.09.10.11.12.14.15.16.17.18.19.20.21.23.24.26.27.28.29.30

i file generati in questo caso saranno nominati progressivamente

Numero1.txt , Numero2.txt , Numero3.txt , Numero4.txt , Numero5.txt

e avranno ognuno questo semplice formato:

Numero1
15
79
29
72
11
41
62
66
50
90
46
88
66
26
75
08
26
70
08
06
01
84
88
58
57
09
09
18
03
...

es. di codice per analizzare la prima colonna... (gli altri 4 sono del tutto analoghi cambiano solo i numeri di colonna rispettivi)

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Carichiamo i dati dal file CSV
data = pd.read_csv('Numero1.txt')

# Estraiamo la colonna 'Numero' come feature (X) e target (y)
X = data[['Numero1']]
y = data['Numero1']

# Dividiamo i dati in set di allenamento e set di test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Creiamo e addestriamo il modello di regressione lineare
model = LinearRegression()
model.fit(X_train, y_train)

# Valutiamo le prestazioni del modello
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print("Mean Squared Error:", mse)

# Facciamo alcune predizioni
predictions = model.predict(X_test[:1])  # qui si può cambiare il numero di "valori predetti"
print("Predizioni:", predictions)


import numpy as np

# Assume che 'predictions' sia la lista delle predizioni ottenute dal modello
#predictions = [90., 29., 30., 78., 61.]

# Ottieni gli indici dei valori ordinati in ordine decrescente
sorted_indices = np.argsort(predictions)[::-1]

# Seleziona solo il migliore tra i 5
best_prediction = predictions[sorted_indices[0]]

print("Miglior predizione tra i primi 5:", best_prediction)


# NESSUNA CERTEZZA SOLO POCA PROBABILITA'

es. di output e di prev su FI x E/A e ambetto

(nuovoambientepy38) C:\Users\admin\Desktop\py5>python analizzasololaposizione1.py
Mean Squared Error: 4.881146634904318e-27
Predizioni: [83.]
Miglior predizione tra i primi 5: 82.99999999999989

Nessuna Certezza Solo Poca Probabilità


curiosita tecnica relativa: il valore di Mean Squared Error è esattamente opposto a quello di Rquadro ovvero + piccolo è... e meglio è...
mentre l'Rquadro più si avvicina al valore massimo (1) e + il modello si applica bene all'analisi relativa...


A proposito di AI e di programmazione guardate dove sono già arrivati...

 

[lotto_tom75]

Riporto per condivisione e tipo backup online alcuni script python realizzati con chatgpt per cercare di implementare vari sistemi di ricerca, analisi e riduzione predittiva di tipo neurale al fine di poterli anche ottimizzare per uno o più aspetti collaborando tutti insieme...

Analisi con modello ARIMA e ricerca configurazione dei suoi parametri ottimali mediante controllo con RQUADRO. Questa versione analizza un file con i numeri degli estratti o dei soli sfaldati con gli eventualmente non usciti sostituiti da 00 e con le righe ordinate con i numeri in ordine crescente d a sx a dx con un formato di questo tipo:

Indice,Estratti
1,15.18.71.81.00
2,42.46.60.79.00
3,28.29.41.74.00
4,17.46.59.72.00
5,11.15.19.73.85
6,11.23.41.71.00
7,62.84.85.00.00
8,19.20.65.66.00
9,38.43.50.52.68
...

# by lotto_tom75 & chatgpt

import pandas as pd
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import r2_score
import math
import time
import logging


# Inizio del tempo di elaborazione
start_time = time.time()

# Imposta il logger di Python per ignorare i messaggi di avviso
logging.getLogger().setLevel(logging.ERROR)

import warnings

# Ignora tutti i messaggi di avviso
warnings.filterwarnings("ignore")

# Inizio del tempo di elaborazione
start_time = time.time()

print("Elaborazione in corso...")

# Carica i dati estratti dal file CSV, specificando il tipo di dati delle colonne
data = pd.read_csv('sfaldamenti-gruppobase-ordinamento-usciti-da-sx-a-dx.txt', dtype={'Indice': int, 'Estratti': str})

# Prepara i dati per l'analisi
# Converti la colonna degli estratti in una lista di interi
estratti = []
data['Estratti'].apply(lambda x: estratti.extend(map(int, x.split('.'))))

# Definisci una funzione per calcolare R quadro
def compute_r_squared(ground_truth, predictions):
    return r2_score(ground_truth, predictions)

# Funzione per fare previsioni utilizzando il modello ARIMA ottimale
def make_prediction(serie_temporale, order):
    # Costruisci il modello ARIMA utilizzando i parametri ottimali
    model = ARIMA(serie_temporale, order=order)
    model_fit = model.fit()

    # Fai previsioni sul set di dati
    predictions = model_fit.forecast(steps=5)  # Cambia steps a 10 se vuoi 10 predizioni
    return predictions

# Imposta il valore di R quadro desiderato per interrompere l'analisi
target_r_squared = 0.75  # Valore massimo teorico di R quadro con le ultime 3 estrazioni

# Imposta il numero iniziale di ultime estrazioni da considerare
num_ultime_estr = 9  # Considera solo le ultime 3 estrazioni inizialmente

# Trova i parametri ARIMA ottimali
best_r_squared = -float('inf')
best_order = None
best_predictions = None

#while best_r_squared < target_r_squared:
while num_ultime_estr > 0 and best_r_squared < target_r_squared:
    # Resto del codice...

    print(f"Analisi delle ultime {num_ultime_estr} estrazioni...")
    estratti_temp = estratti[-num_ultime_estr:]

    for p in range(11):  # Prova valori per p da 0 a 10
        for d in range(3):  # Prova valori per d da 0 a 2
            for q in range(3):  # Prova valori per q da 0 a 2
                # Costruisci il modello ARIMA
                model = ARIMA(estratti_temp, order=(p, d, q))
                try:
                    model_fit = model.fit()
                    # Fai predizioni sul set di dati
                    predictions = model_fit.predict()

                    # Calcola R quadro
                    r_squared = compute_r_squared(estratti_temp, predictions)

                    # Aggiorna i parametri se R quadro è migliorato
                    if r_squared > best_r_squared:
                        best_r_squared = r_squared
                        best_order = (p, d, q)
                        best_predictions = predictions
                        print(f"Parametri ARIMA ottimali aggiornati: {best_order}, R quadro massimo trovato: {best_r_squared}")
                except:
                    continue

    # Stampa il risultato corrente
    print("Parametri ARIMA ottimali:", best_order)
    print("R quadro massimo trovato:", best_r_squared)

    # Fai previsioni utilizzando i parametri ARIMA ottimali
    predictions = make_prediction(estratti, best_order)
    print("Previste per i prossimi 5/10 estratti:", predictions)

    # Funzione per arrotondare in base alla parte decimale
    def arrotonda_misto(numero):
        parte_intera = int(numero)
        parte_decimale = numero - parte_intera
        if parte_decimale >= 0.5:
            return math.ceil(numero)
        else:
            return math.floor(numero)

    # Stampare i numeri arrotondati per eccesso, per difetto e "mixati"
    print("Numeri arrotondati per eccesso:")
    for previsione in predictions:
        print(math.ceil(previsione), end=" ")
    print("\n")

    print("Numeri arrotondati per difetto:")
    for previsione in predictions:
        print(math.floor(previsione), end=" ")
    print("\n")

    print("Numeri arrotondati in base alla parte decimale:")
    for previsione in predictions:
        print(arrotonda_misto(previsione), end=" ")
    print("\n")

    # Aumenta il numero di ultime estrazioni da considerare solo se non si è raggiunto il valore massimo di R quadro
    if best_r_squared < target_r_squared:
        num_ultime_estr -= 1

# Fine del tempo di elaborazione
end_time = time.time()

# Calcolare il tempo impiegato
elapsed_time = end_time - start_time

# Stampare il tempo impiegato
print("Tempo impiegato per l'elaborazione:", round(elapsed_time, 2), "secondi")

Analisi con modello ARIMA e ricerca configurazione dei suoi parametri ottimali mediante controllo con RQUADRO. Questa versione analizza un file con i numeri degli estratti o dei soli sfaldati con gli eventualmente non usciti sostituiti da 00 e con le righe che mantengono le esatte posizioni di uscita presenti nell'archivio estrazioni esaminato con questo formato (seguendo lo stesso esempio sopra).

Indice,Estratti
1,15.71.18.00.81
2,79.60.46.00.42
3,29.74.08.41.28
4,00.72.17.46.59
5,11.15.19.73.85
6,41.11.71.23.00
7,62.85.00.84.00
8,66.65.00.20.19
9,50.43.68.38.52
...

# by lotto_tom75 & chatgpt

import pandas as pd
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import r2_score
import math
import time
import logging


# Inizio del tempo di elaborazione
start_time = time.time()

# Imposta il logger di Python per ignorare i messaggi di avviso
logging.getLogger().setLevel(logging.ERROR)

import warnings

# Ignora tutti i messaggi di avviso
warnings.filterwarnings("ignore")

# Inizio del tempo di elaborazione
start_time = time.time()

print("Elaborazione in corso...")

# Carica i dati estratti dal file CSV, specificando il tipo di dati delle colonne
data = pd.read_csv('sfaldamenti-gruppobase-ordinamento-usciti-posizioni-reali.txt', dtype={'Indice': int, 'Estratti': str})

# Prepara i dati per l'analisi
# Converti la colonna degli estratti in una lista di interi
estratti = []
data['Estratti'].apply(lambda x: estratti.extend(map(int, x.split('.'))))

# Definisci una funzione per calcolare R quadro
def compute_r_squared(ground_truth, predictions):
    return r2_score(ground_truth, predictions)

# Funzione per fare previsioni utilizzando il modello ARIMA ottimale
def make_prediction(serie_temporale, order):
    # Costruisci il modello ARIMA utilizzando i parametri ottimali
    model = ARIMA(serie_temporale, order=order)
    model_fit = model.fit()

    # Fai previsioni sul set di dati
    predictions = model_fit.forecast(steps=5)  # Cambia steps a 10 se vuoi 10 predizioni
    return predictions

# Imposta il valore di R quadro desiderato per interrompere l'analisi
target_r_squared = 0.75  # Valore massimo teorico di R quadro con le ultime 3 estrazioni

# Imposta il numero iniziale di ultime estrazioni da considerare
num_ultime_estr = 9  # Considera solo le ultime 3 estrazioni inizialmente

# Trova i parametri ARIMA ottimali
best_r_squared = -float('inf')
best_order = None
best_predictions = None

#while best_r_squared < target_r_squared:
while num_ultime_estr > 0 and best_r_squared < target_r_squared:
    # Resto del codice...

    print(f"Analisi delle ultime {num_ultime_estr} estrazioni...")
    estratti_temp = estratti[-num_ultime_estr:]

    for p in range(11):  # Prova valori per p da 0 a 10
        for d in range(3):  # Prova valori per d da 0 a 2
            for q in range(3):  # Prova valori per q da 0 a 2
                # Costruisci il modello ARIMA
                model = ARIMA(estratti_temp, order=(p, d, q))
                try:
                    model_fit = model.fit()
                    # Fai predizioni sul set di dati
                    predictions = model_fit.predict()

                    # Calcola R quadro
                    r_squared = compute_r_squared(estratti_temp, predictions)

                    # Aggiorna i parametri se R quadro è migliorato
                    if r_squared > best_r_squared:
                        best_r_squared = r_squared
                        best_order = (p, d, q)
                        best_predictions = predictions
                        print(f"Parametri ARIMA ottimali aggiornati: {best_order}, R quadro massimo trovato: {best_r_squared}")
                except:
                    continue

    # Stampa il risultato corrente
    print("Parametri ARIMA ottimali:", best_order)
    print("R quadro massimo trovato:", best_r_squared)

    # Fai previsioni utilizzando i parametri ARIMA ottimali
    predictions = make_prediction(estratti, best_order)
    print("Previste per i prossimi 5/10 estratti:", predictions)

    # Funzione per arrotondare in base alla parte decimale
    def arrotonda_misto(numero):
        parte_intera = int(numero)
        parte_decimale = numero - parte_intera
        if parte_decimale >= 0.5:
            return math.ceil(numero)
        else:
            return math.floor(numero)

    # Stampare i numeri arrotondati per eccesso, per difetto e "mixati"
    print("Numeri arrotondati per eccesso:")
    for previsione in predictions:
        print(math.ceil(previsione), end=" ")
    print("\n")

    print("Numeri arrotondati per difetto:")
    for previsione in predictions:
        print(math.floor(previsione), end=" ")
    print("\n")

    print("Numeri arrotondati in base alla parte decimale:")
    for previsione in predictions:
        print(arrotonda_misto(previsione), end=" ")
    print("\n")

    # Aumenta il numero di ultime estrazioni da considerare solo se non si è raggiunto il valore massimo di R quadro
    if best_r_squared < target_r_squared:
        num_ultime_estr -= 1

# Fine del tempo di elaborazione
end_time = time.time()

# Calcolare il tempo impiegato
elapsed_time = end_time - start_time

# Stampare il tempo impiegato
print("Tempo impiegato per l'elaborazione:", round(elapsed_time, 2), "secondi")

Analisi con modello RNN e ricerca configurazione dei suoi parametri ottimali mediante controllo con RQUADRO e altri sistemi di ottimizzazione dello stesso. Questa versione analizza un file con i numeri degli estratti o dei soli sfaldati con gli eventualmente non usciti sostituiti da 00 e con le righe che mantengono le esatte posizioni di uscita presenti nell'archivio estrazioni esaminato con questo formato (seguendo lo stesso esempio sopra). Come output oltre a generare i numeri a video genera anche un realtivo grafico a barre evidenziando in arancione il teorico e ipotetico numero in uscita.

# by lotto_tom75 & chatgpt

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import LSTM, Dense

# Carica i dati estratti dal file CSV
data = pd.read_csv('sfaldamenti-gruppobase-ordinamento-usciti-posizioni-reali.txt', dtype={'Indice': int, 'Estratti': str})

# Seleziona solo le ultime 100 righe
ultime_righe = data.tail(100)

# Prepara i dati per l'analisi
# Converti la colonna degli estratti in una lista di interi
estratti = []
ultime_righe['Estratti'].apply(lambda x: estratti.extend(map(int, x.split('.'))))

# Normalizza i dati
scaler = MinMaxScaler(feature_range=(0, 1))
estratti_normalized = scaler.fit_transform(np.array(estratti).reshape(-1, 1))

# Crea le sequenze di input e output per il modello RNN
def create_sequences(data, seq_length):
    X, y = [], []
    for i in range(len(data)-seq_length):
        X.append(data[i:i+seq_length])
        y.append(data[i+seq_length])
    return np.array(X), np.array(y)

# Definisci la lunghezza della sequenza di input
seq_length = 10

# Crea le sequenze di input e output
X, y = create_sequences(estratti_normalized, seq_length)

# Dividi i dati in set di addestramento e set di test
train_size = int(len(X) * 0.8)
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

# Definisci il modello RNN
model = Sequential([
    LSTM(50, activation='relu', input_shape=(seq_length, 1)),
    Dense(1)
])
model.compile(optimizer='adam', loss='mean_squared_error')

# Addestra il modello
model.fit(X_train, y_train, epochs=100, batch_size=32, verbose=1)

# Valuta il modello
train_loss = model.evaluate(X_train, y_train, verbose=0)
test_loss = model.evaluate(X_test, y_test, verbose=0)
print(f'Train Loss: {train_loss:.4f}')
print(f'Test Loss: {test_loss:.4f}')

# Effettua previsioni utilizzando il modello addestrato
predictions = model.predict(X_test)

# Denormalizza le previsioni
predictions = scaler.inverse_transform(predictions)
y_test_denormalized = scaler.inverse_transform(y_test)

# Visualizza i risultati
plt.plot(y_test_denormalized, label='True')
plt.plot(predictions, label='Predicted')
plt.legend()
plt.show()

# Visualizza i risultati testuali
print("Numeri predetti:")
for predetto in predictions:
    print(round(predetto[0]))

es. di output grafico generato dallo script soprastante analizzando tutte le 10k e oltre righe di sfaldamenti della 77abs x A su FI dal 1871.

Vedi l'allegato 2280411
es. di output grafico generato dallo script soprastante analizzando solo le ultime 100 righe di sfaldamenti della 77abs x A su FI dal 1871.

Vedi l'allegato 2280412

i files py per generare in un colpo solo gli archivi delle estrazioni o degli sfaldamenti per i gruppi base voluti "intepretabili dalle AI py sopra descritte a partire dal file di archivio estrazioni e da quello del gruppo base voluto li trovate qui in questo altro thread.


Adesso mi piacerebbe provare a realizzare in py grazie a chatgpt o altra AI qualcosa che assomigli a NNCLUST a GMDH e a PYTHIA

Se qualcuno ci ruscirà o se ci arriverà prima.. non faccia il trex... e me lo faccia sapere... Thanks

Come riportato anche in questo altro thread analogo mi appunto e condivido che la linea arancione "predicted" by AI RNN implementata in python, per quanto riguarda l'analisi meno estesa e sulle sole ultime 100 estrazioni, avrebbe in questo caso centrato ambo 41-43 al 2° colpo su ruota target (FI) come trasformata (purtroppo non avevo postato i relativi numeri per non mettere troppa carne al fuoco) nella rispettiva lunghetta numerica da 36 a 43 (tutti numeri consecutivi).