Novità

Intelligenza artificiale e lotto 🤖🎱📈📉🎯

Thanks to like l8py :)

Prox forse...

[21:52:55][INFO] Lunghezza sequenza: 5
[21:52:55][INFO] Righe da analizzare: 60
[21:52:55][INFO] Soglia minima: 90.0%


=== CONDIZIONE OTTIMALE TROVATA ===
[21:52:55][INFO] Ruota: FI
[21:52:55][INFO] File binario: b1.txt
[21:52:55][INFO] Pattern analizzato: 00110
[21:52:55][INFO] Occorrenze '0': 0
[21:52:55][INFO] Occorrenze '1': 2
[21:52:55][INFO] Sequenza binaria risultante: 1011111 alias : 0011111 : 31
[21:52:55][INFO] Numero decimale: 95 -> 5 ??
[21:52:55][INFO] =


[21:53:01][INFO] Per b3.txt: 6 split con probabilità >= soglia.
[21:53:01][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:53:01][INFO] Ruota: PA
[21:53:01][INFO] File binario: b3.txt
[21:53:01][INFO] Pattern analizzato: 11111
[21:53:01][INFO] Occorrenze '0': 0
[21:53:01][INFO] Occorrenze '1': 3
[21:53:01][INFO] Sequenza binaria risultante: 0101010 alias 0101011 : 43
[21:53:01][INFO] Numero decimale: 42


[21:52:59][INFO] Per b2.txt: 6 split con probabilità >= soglia.
[21:52:59][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:52:59][INFO] Ruota: PA
[21:52:59][INFO] File binario: b2.txt
[21:52:59][INFO] Pattern analizzato: 11000
[21:52:59][INFO] Occorrenze '0': 1
[21:52:59][INFO] Occorrenze '1': 0
[21:52:59][INFO] Sequenza binaria risultante: 0110110 alias 0111110 : 62
[21:52:59][INFO] Numero decimale: 54
[21:52:59][INFO] ================================


[21:53:05][INFO] Per b2.txt: 7 split con probabilità >= soglia.
[21:53:05][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:53:05][INFO] Ruota: NZ
[21:53:05][INFO] File binario: b2.txt
[21:53:05][INFO] Pattern analizzato: 11111
[21:53:05][INFO] Occorrenze '0': 0
[21:53:05][INFO] Occorrenze '1': 4
[21:53:05][INFO] Sequenza binaria risultante: 0000001
[21:53:05][INFO] Numero decimale: 1
[21:53:05][INFO] ================================
[21:53:07][INFO]



Nessunissima Certezza Solo Pochissima Probabilità
 
lotto_tom75 ha scritto:
Thanks to like l8py :)

Prox forse...

[21:52:55][INFO] Lunghezza sequenza: 5
[21:52:55][INFO] Righe da analizzare: 60
[21:52:55][INFO] Soglia minima: 90.0%


=== CONDIZIONE OTTIMALE TROVATA ===
[21:52:55][INFO] Ruota: FI
[21:52:55][INFO] File binario: b1.txt
[21:52:55][INFO] Pattern analizzato: 00110
[21:52:55][INFO] Occorrenze '0': 0
[21:52:55][INFO] Occorrenze '1': 2
[21:52:55][INFO] Sequenza binaria risultante: 1011111 alias : 0011111 : 31
[21:52:55][INFO] Numero decimale: 95 -> 5 ??
[21:52:55][INFO] =


[21:53:01][INFO] Per b3.txt: 6 split con probabilità >= soglia.
[21:53:01][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:53:01][INFO] Ruota: PA
[21:53:01][INFO] File binario: b3.txt
[21:53:01][INFO] Pattern analizzato: 11111
[21:53:01][INFO] Occorrenze '0': 0
[21:53:01][INFO] Occorrenze '1': 3
[21:53:01][INFO] Sequenza binaria risultante: 0101010 alias 0101011 : 43
[21:53:01][INFO] Numero decimale: 42


[21:52:59][INFO] Per b2.txt: 6 split con probabilità >= soglia.
[21:52:59][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:52:59][INFO] Ruota: PA
[21:52:59][INFO] File binario: b2.txt
[21:52:59][INFO] Pattern analizzato: 11000
[21:52:59][INFO] Occorrenze '0': 1
[21:52:59][INFO] Occorrenze '1': 0
[21:52:59][INFO] Sequenza binaria risultante: 0110110 alias 0111110 : 62
[21:52:59][INFO] Numero decimale: 54
[21:52:59][INFO] ================================


[21:53:05][INFO] Per b2.txt: 7 split con probabilità >= soglia.
[21:53:05][INFO]
=== CONDIZIONE OTTIMALE TROVATA ===
[21:53:05][INFO] Ruota: NZ
[21:53:05][INFO] File binario: b2.txt
[21:53:05][INFO] Pattern analizzato: 11111
[21:53:05][INFO] Occorrenze '0': 0
[21:53:05][INFO] Occorrenze '1': 4
[21:53:05][INFO] Sequenza binaria risultante: 0000001
[21:53:05][INFO] Numero decimale: 1
[21:53:05][INFO] ================================
[21:53:07][INFO]



Nessunissima Certezza Solo Pochissima Probabilità
Clicca per espandere...

Questa sera estrazione per me da dimenticare... ma FI 31 e NZ 1 al 2° colpo seppur fuori posizione...
Io forse ritenterò l'unica rimasta PA anche per domani...
 
lotto_tom75 ha scritto:
Nonostante sia da ottimizzare e correggere su su molti punti condivido il code dell'ultima versione (script-analisi-0-1-versioneforsefinale-38.py) x i + smanettoni tra di voi :) In questa versione è stato corretto l'ordinamento di ricerca (dal basso verso l'alto e l'implementazione di un abbozzo di automazione e di ricerca della condizione teoricamente + ottimale). Anche l'interfaccia presenta molti + campi e bottoni rispetto alla soprastante.

Codice: 
import os
import time
from datetime import datetime
from tkinter import Tk, filedialog, Checkbutton, IntVar, Button, Label, Entry, Frame
from collections import Counter, defaultdict
import winsound

class Logger:
    def __init__(self, cartella_output):
        self.start_time = time.time()
        self.log_filename = os.path.join(cartella_output,
                                         f"log_elaborazione_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt")

    def log(self, messaggio):
        with open(self.log_filename, 'a', encoding='utf-8') as f:
            timestamp = datetime.now().strftime('%H:%M:%S')
            f.write(f"[{timestamp}] {messaggio}\n")
        print(messaggio)

    def tempo_totale(self):
        tempo_totale = time.time() - self.start_time
        return f"{tempo_totale:.2f} secondi"

class ReportCasiOttimali:
    def __init__(self, cartella_output):
        self.report_path = os.path.join(cartella_output, "reportcasiottimali.txt")
        with open(self.report_path, 'w', encoding='utf-8') as f:
            f.write("=== Report Casi Ottimali ===\n\n")
        self.casi_trovati = False

    def aggiungi_caso(self, file_estrazioni, file_b, posizione, prob_0, prob_1):
        self.casi_trovati = True
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"File estrazioni: {file_estrazioni}\n")
            f.write(f"File binario: {file_b}\n")
            f.write(f"Probabilità '0': {prob_0:.2%}\n")
            f.write(f"Probabilità '1': {prob_1:.2%}\n")
            f.write("-" * 50 + "\n")

    def finalizza_report(self):
        if not self.casi_trovati:
            with open(self.report_path, 'a', encoding='utf-8') as f:
                f.write("Nessun caso ottimale trovato.\n")

class ReportRuote:
    def __init__(self, cartella_output, nome_file):
        self.report_path = os.path.join(cartella_output, nome_file)
        if not os.path.exists(self.report_path):
            with open(self.report_path, 'w', encoding='utf-8') as f:
                f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

    def aggiungi_ruota(self, ruota):
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"{ruota}\n")

class CarrelloPredizioni:
    def __init__(self):
        self.carrelli = defaultdict(lambda: ['_'] * 7)
        self.ruota_corrente = None

    def set_ruota(self, nome_file_input):
        if nome_file_input.startswith('estrazioni-'):
            self.ruota_corrente = nome_file_input.split('-')[1].split('.')[0]

    def aggiungi_predizione(self, file_origine, posizione, valore):
        file_base = os.path.basename(file_origine)
        parti = file_base.split('-')
        numero_file = ''.join(filter(str.isdigit, parti[0]))
        chiave = f"b{numero_file}"
        try:
            posizione = int(parti[1].split('.')[0])
            if 0 <= posizione < 7:
                self.carrelli[chiave][posizione] = valore
        except (ValueError, IndexError) as e:
            print(f"Errore: {e}")

    def mostra_risultati(self, logger, cartella_output):
        logger.log("\n=== Risultati Finali ===")
        script_dir = os.path.dirname(os.path.abspath(__file__))
        report_path = os.path.join(script_dir, "previsionielaborate.txt")
        numeri_decimali = []
        for chiave in sorted(self.carrelli.keys()):
            sequenza_binaria = ''.join(self.carrelli[chiave])
            numero_decimale = str(int(sequenza_binaria, 2))
            numeri_decimali.append(numero_decimale)
            logger.log(f"{chiave}.txt: {numero_decimale} (binario: {sequenza_binaria} = {int(sequenza_binaria, 2)})")
        with open(report_path, 'a', encoding='utf-8') as report:
            if self.ruota_corrente and numeri_decimali:
                report.write(f"{self.ruota_corrente} {'-'.join(numeri_decimali)}\n")
        logger.log("=====================")
        logger.log(f"Report salvato in: {report_path}")

def decimale_a_binario(decimale):
    return '.'.join(format(int(decimale), '07b'))

def converte_file_decimale(file_decimale, cartella_output, logger):
    colonne = []
    with open(file_decimale, 'r') as file:
        for linea in file:
            valori = linea.strip().split('.')
            for i, valore in enumerate(valori):
                if len(colonne) <= i:
                    colonne.append([])
                colonne[i].append(decimale_a_binario(valore))
    file_binari = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{i + 1}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_binari.append(nome_file)
        logger.log(f"File binario generato: {nome_file}")
    return file_binari

def split_file_binario(file_binario, cartella_output, logger):
    base_name = os.path.basename(file_binario)
    numero_file = ''.join(filter(str.isdigit, base_name.split('.')[0]))
    with open(file_binario, 'r') as file:
        righe = [line.strip().split('.') for line in file]
        colonne = list(zip(*righe))
    file_splittati = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{numero_file}-{i}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_splittati.append(nome_file)
        logger.log(f"File splittato generato: {nome_file}")
    return file_splittati

def carica_dati(file_path):
    with open(file_path, 'r') as file:
        # Legge i dati e INVERTE l'ordine per avere i più vecchi in alto durante l'analisi
        dati = [bit for line in file for bit in line.strip().split('.')]
        return dati[::-1]  # <-- Modifica chiave qui

def analizza_file(file_binario, lunghezza_sequenza, carrello, logger, report_ottimali, file_estrazioni,
                  soglia_minima, analisi_automatica):
    posizione = int(os.path.basename(file_binario).split('-')[1].split('.')[0])
    dati = carica_dati(file_binario)  # Dati ora sono invertiti: [vecchio, ..., recente]

    logger.log(f"\nAnalisi pattern per {file_binario}")
    logger.log(f"Posizione bit analizzata: bit{posizione}.txt")
    logger.log(f"Lunghezza sequenza pattern: {lunghezza_sequenza}")

    # Controllo per assicurarsi che la lunghezza del pattern sia valida
    if lunghezza_sequenza <= 0:
        logger.log(f"Lunghezza sequenza pattern non valida: {lunghezza_sequenza}")
        return False

    # Pattern iniziale preso dalla FINE dei dati invertiti (corrisponde ai più RECENTI nel file originale)
    initial_pattern = tuple(dati[-lunghezza_sequenza:])  # <-- Modifica qui

    preceding_bits = []

    # Analizza dal basso (vecchio) verso l'alto (recente) nei dati invertiti
    for i in range(len(dati) - lunghezza_sequenza):
        current_window = tuple(dati[i:i + lunghezza_sequenza])
        if current_window == initial_pattern and i + lunghezza_sequenza < len(dati):
            # Il bit successivo è quello DOPO la finestra, verso l'alto (più recente)
            preceding_bit = dati[i + lunghezza_sequenza]
            preceding_bits.append(preceding_bit)

    count_0 = preceding_bits.count('0')
    count_1 = preceding_bits.count('1')
    total = len(preceding_bits)

    if total == 0:
        prob_0, prob_1 = 0.5, 0.5
    else:
        prob_0 = count_0 / total
        prob_1 = count_1 / total

    occ = {'0': count_0, '1': count_1}
    TOLLERANZA = 0.0001
    is_optimal = any(abs(prob - 1.0) < TOLLERANZA for prob in [prob_0, prob_1])

    # Controllo per identificare i casi con esattamente un bit inferiore alla soglia minima
    if analisi_automatica:
        bit_inferiori = [bit for bit in preceding_bits if (bit == '0' and prob_0 < soglia_minima / 100) or (bit == '1' and prob_1 < soglia_minima / 100)]
        if len(bit_inferiori) == 1:
            file_b = os.path.basename(file_binario).split('-')[0] + ".txt"
            report_ottimali.aggiungi_caso(
                os.path.basename(file_estrazioni),
                file_b,
                posizione,
                prob_0,
                prob_1
            )
            return True

    valore_predetto = '0' if prob_0 > prob_1 else '1'
    prob_valore = prob_0 if valore_predetto == '0' else prob_1

    logger.log(f"Sequenza iniziale: {''.join(initial_pattern)}")
    logger.log(f"Occorrenze trovate del pattern: {total}")
    logger.log(f"Probabilità '0': {prob_0:.2%} (occorrenze: {count_0})")
    logger.log(f"Probabilità '1': {prob_1:.2%} (occorrenze: {count_1})")
    logger.log(f"Valore predetto: {valore_predetto} (probabilità: {prob_valore:.2%})")

    carrello.aggiungi_predizione(file_binario, posizione, valore_predetto)

    # Aggiunto controllo per fermarsi se tutte le probabilità sono maggiori o uguali alla soglia
    if prob_0 >= soglia_minima / 100 and prob_1 >= soglia_minima / 100:
        return True

    return is_optimal

def processo_automatico(file_input, lunghezza_sequenza, righe_da_analizzare=10000, soglia_minima=100, analisi_automatica=False):
    cartella_output = os.path.dirname(os.path.abspath(file_input))
    nome_file = os.path.basename(file_input)
    logger = Logger(cartella_output)
    report_ottimali = ReportCasiOttimali(cartella_output)
    report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
    report_ruote_non_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTENONOTTIMALI.txt")
    logger.log(f"Inizio elaborazione")
    logger.log(f"File input: {nome_file}")
    logger.log(f"Cartella output: {cartella_output}")
    logger.log(f"Lunghezza sequenza: {lunghezza_sequenza}")
    logger.log(f"Righe da analizzare: {righe_da_analizzare}")
    logger.log(f"Soglia minima: {soglia_minima}%")
    logger.log("\nConversione file decimale in binari...")

    with open(file_input, 'r') as file:
        lines = []
        for i, line in enumerate(file):
            if i < righe_da_analizzare:
                lines.append(line)
            else:
                break

    temp_file = os.path.join(cartella_output, "temp_estrazioni.txt")
    with open(temp_file, 'w') as file:
        file.writelines(lines)

    file_binari = converte_file_decimale(temp_file, cartella_output, logger)
    carrello = CarrelloPredizioni()
    carrello.set_ruota(nome_file)
    is_ruota_ottimale = True

    for file_binario in file_binari:
        logger.log(f"\nElaborazione {os.path.basename(file_binario)}...")
        file_splittati = split_file_binario(file_binario, cartella_output, logger)
        for file_splittato in file_splittati:
            if not analizza_file(file_splittato, lunghezza_sequenza, carrello, logger, report_ottimali, nome_file, soglia_minima, analisi_automatica):
                is_ruota_ottimale = False

    if is_ruota_ottimale:
        report_ruote_ottimali.aggiungi_ruota(carrello.ruota_corrente)
    else:
        report_ruote_non_ottimali.aggiungi_ruota(carrello.ruota_corrente)

    carrello.mostra_risultati(logger, cartella_output)
    report_ottimali.finalizza_report()
    tempo_totale = logger.tempo_totale()
    logger.log(f"\nTempo totale di elaborazione: {tempo_totale}")
    logger.log(f"Report casi ottimali salvato in: {report_ottimali.report_path}")
    logger.log(f"Report ruote ottimali salvato in: {report_ruote_ottimali.report_path}")
    logger.log(f"Report ruote non ottimali salvato in: {report_ruote_non_ottimali.report_path}")

    os.remove(temp_file)

    return report_ottimali.casi_trovati

def ottieni_percorso_file_estrazioni(ruota):
    return os.path.join(ruota, f"estrazioni-{ruota}.txt")

def inizializza_report_ruote():
    script_dir = os.path.dirname(os.path.abspath(__file__))
    for nome_file in ["RUOTEOTTIMALI.txt", "RUOTENONOTTIMALI.txt"]:
        report_path = os.path.join(script_dir, nome_file)
        with open(report_path, 'w', encoding='utf-8') as f:
            f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

def main():
    root = Tk()
    root.title("Seleziona Ruote")

    pattern_frame = Frame(root)
    pattern_frame.pack(pady=10)
    Label(pattern_frame, text="Lunghezza pattern:").pack(side='left')
    pattern_length = Entry(pattern_frame, width=5)
    pattern_length.insert(0, "18")
    pattern_length.pack(side='left', padx=5)

    righe_frame = Frame(root)
    righe_frame.pack(pady=10)
    Label(righe_frame, text="Prime righe da analizzare:").pack(side='left')
    righe_da_analizzare = Entry(righe_frame, width=5)
    righe_da_analizzare.insert(0, "10000")
    righe_da_analizzare.pack(side='left', padx=5)

    soglia_frame = Frame(root)
    soglia_frame.pack(pady=10)
    Label(soglia_frame, text="Soglia minima di probabilità (%):").pack(side='left')
    soglia_minima = Entry(soglia_frame, width=5)
    soglia_minima.insert(0, "100")
    soglia_minima.pack(side='left', padx=5)

    analisi_automatica_var = IntVar()
    Checkbutton(root, text="Analisi e selezione automatica", variable=analisi_automatica_var).pack(pady=5)

    Label(root, text="Seleziona le ruote da analizzare:").pack()

    ruote = ["BA", "CA", "FI", "GE", "MI", "NA", "PA", "RO", "TO", "VE", "NZ"]
    ruote_vars = {ruota: IntVar() for ruota in ruote}

    checkbuttons_frame = Frame(root)
    checkbuttons_frame.pack(pady=5)

    for ruota in ruote:
        Checkbutton(checkbuttons_frame, text=ruota, variable=ruote_vars[ruota]).pack(anchor='w')

    buttons_frame = Frame(root)
    buttons_frame.pack(pady=10)

    def seleziona_tutto():
        for var in ruote_vars.values():
            var.set(1)

    def deseleziona_tutto():
        for var in ruote_vars.values():
            var.set(0)

    def analizza():
        try:
            lunghezza_seq = int(pattern_length.get())
            righe = int(righe_da_analizzare.get())
            soglia = float(soglia_minima.get())
            analisi_automatica = analisi_automatica_var.get()
            ruote_selezionate = [ruota for ruota, var in ruote_vars.items() if var.get()]

            inizializza_report_ruote()

            if analisi_automatica:
                lunghezza_seq_iniziale = lunghezza_seq
                while True:
                    casi_trovati = False
                    for ruota in ruote_selezionate:
                        file_input = ottieni_percorso_file_estrazioni(ruota)
                        if os.path.exists(file_input):
                            logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                            logger.log(f"Analizzando ruota: {ruota}")
                            logger.log(f"File input: {file_input}")
                            logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                            logger.log(f"Righe da analizzare: {righe}")
                            logger.log(f"Soglia minima: {soglia}%")
                            if processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica):
                                casi_trovati = True
                                logger.log(f"Ruota ottimale trovata: {ruota}")
                                report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
                                report_ruote_ottimali.aggiungi_ruota(f"RUOTA OTTIMALE: {ruota}")
                                winsound.Beep(1000, 2000)  # Emette un bip sonoro a 1000 Hz per 2 secondi
                                break
                    if casi_trovati:
                        break
                    lunghezza_seq += 1
                    logger.log(f"Aumentando la lunghezza del pattern a {lunghezza_seq}")
            else:
                for ruota in ruote_selezionate:
                    file_input = ottieni_percorso_file_estrazioni(ruota)
                    if os.path.exists(file_input):
                        logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                        logger.log(f"Analizzando ruota: {ruota}")
                        logger.log(f"File input: {file_input}")
                        logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                        logger.log(f"Righe da analizzare: {righe}")
                        logger.log(f"Soglia minima: {soglia}%")
                        processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica)
                    else:
                        print(f"File di estrazioni per la ruota {ruota} non trovato.")
        except ValueError:
            print("Errore: inserire valori numerici validi.")

    Button(buttons_frame, text="Seleziona Tutto", command=seleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Deseleziona Tutto", command=deseleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Analizza", command=analizza).pack(side='left', padx=5)

    root.mainloop()

if __name__ == "__main__":
    main()

Per testarlo, e magari contribuire alla sua ottimizzazione e/o correzione, è necessario creare 11 cartelle : BA , CA , FI ecc... fino a NZ con dentro i rispettivi file estrazioni-BA.txt ecc... contenenti ognuno le estrazioni della rispettiva ruota con la prima estrazione in alto e l'ultima in basso in formato con i 5 estratti a doppia cifra (i numeri da 1 a 9 con lo 0 davanti) intervallata da carattere punto (es. 01.88.77.32.05). AI utilizzate per adesso per questo script py: Claude Sonnet 3.5, DeepSeek, ChatGpt e Mistral. Selezionando "Analizza e seleziona automaticamente" lo script continuerà la ricerca ad libitum aumentando la lunghezza del pattern iniziale di una unità ad ogni nuovo ciclo.. Per adesso lo script si potrà interrompere solo bruscamente.. con ctrl + s (pausa) e ctrl + q (prosegui) o con ctrl + c (chiudi) o chiudendo direttamente la finestra dos. Per ovviare a questo comunque basta comunque implementarvi un bottone per chiuderlo in modo + dolce... o non selezionare quell'opzione di analisi automatica... :)

breve schema e spiegazione dell'idea di base che ho avuto e che mi ha spinto a voler cercare di realizzare questo script :

la sequenza di estratti di ogni estrazione e per ogni ruota viene convertita in rispettivi numeri binari a 7 bit i quali vengono a loro volta scomposti nelle 7 colonne di bit (da bit0 a bit6). Queste 7 colonne vengono analizzate una ad una a partire dal basso verso l'alto dopo che è stato costruito un pattern spia di ricerca prelevando i primi elementi di ciascuna colonna a partire dall'alto. Questa operazione si può fare sia staticamente scegliendo una lunghezza fissa sia dinamicamente lasciando appunto allo script di aumentare ad ogni ciclo la lunghezza del pattern di partenza... Lo script dovrà quindi annotarsi tutte le quantità di 0 e di 1 che incontrerà per ciascuna colonna di bit dopo la sequenza del pattern di ricerca e in base alla loro presenza maggiore e quindi relativa probabilità di apparizione ipotizzare quale ci sarà dopo l'ultimo bit in alto della rispettiva colonna analizzata... Per far questo è possibile scegliere statisticamente una % minima di presenza per far si che il bit che la raggiunge o supera sia considerato + probabile dell'altro.



Vedi l'allegato 2296926
Clicca per espandere...
Ciao lotto
lotto_tom75 ha scritto:
Nonostante sia da ottimizzare e correggere su su molti punti condivido il code dell'ultima versione (script-analisi-0-1-versioneforsefinale-38.py) x i + smanettoni tra di voi :) In questa versione è stato corretto l'ordinamento di ricerca (dal basso verso l'alto e l'implementazione di un abbozzo di automazione e di ricerca della condizione teoricamente + ottimale). Anche l'interfaccia presenta molti + campi e bottoni rispetto alla soprastante.

Codice: 
import os
import time
from datetime import datetime
from tkinter import Tk, filedialog, Checkbutton, IntVar, Button, Label, Entry, Frame
from collections import Counter, defaultdict
import winsound

class Logger:
    def __init__(self, cartella_output):
        self.start_time = time.time()
        self.log_filename = os.path.join(cartella_output,
                                         f"log_elaborazione_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt")

    def log(self, messaggio):
        with open(self.log_filename, 'a', encoding='utf-8') as f:
            timestamp = datetime.now().strftime('%H:%M:%S')
            f.write(f"[{timestamp}] {messaggio}\n")
        print(messaggio)

    def tempo_totale(self):
        tempo_totale = time.time() - self.start_time
        return f"{tempo_totale:.2f} secondi"

class ReportCasiOttimali:
    def __init__(self, cartella_output):
        self.report_path = os.path.join(cartella_output, "reportcasiottimali.txt")
        with open(self.report_path, 'w', encoding='utf-8') as f:
            f.write("=== Report Casi Ottimali ===\n\n")
        self.casi_trovati = False

    def aggiungi_caso(self, file_estrazioni, file_b, posizione, prob_0, prob_1):
        self.casi_trovati = True
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"File estrazioni: {file_estrazioni}\n")
            f.write(f"File binario: {file_b}\n")
            f.write(f"Probabilità '0': {prob_0:.2%}\n")
            f.write(f"Probabilità '1': {prob_1:.2%}\n")
            f.write("-" * 50 + "\n")

    def finalizza_report(self):
        if not self.casi_trovati:
            with open(self.report_path, 'a', encoding='utf-8') as f:
                f.write("Nessun caso ottimale trovato.\n")

class ReportRuote:
    def __init__(self, cartella_output, nome_file):
        self.report_path = os.path.join(cartella_output, nome_file)
        if not os.path.exists(self.report_path):
            with open(self.report_path, 'w', encoding='utf-8') as f:
                f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

    def aggiungi_ruota(self, ruota):
        with open(self.report_path, 'a', encoding='utf-8') as f:
            f.write(f"{ruota}\n")

class CarrelloPredizioni:
    def __init__(self):
        self.carrelli = defaultdict(lambda: ['_'] * 7)
        self.ruota_corrente = None

    def set_ruota(self, nome_file_input):
        if nome_file_input.startswith('estrazioni-'):
            self.ruota_corrente = nome_file_input.split('-')[1].split('.')[0]

    def aggiungi_predizione(self, file_origine, posizione, valore):
        file_base = os.path.basename(file_origine)
        parti = file_base.split('-')
        numero_file = ''.join(filter(str.isdigit, parti[0]))
        chiave = f"b{numero_file}"
        try:
            posizione = int(parti[1].split('.')[0])
            if 0 <= posizione < 7:
                self.carrelli[chiave][posizione] = valore
        except (ValueError, IndexError) as e:
            print(f"Errore: {e}")

    def mostra_risultati(self, logger, cartella_output):
        logger.log("\n=== Risultati Finali ===")
        script_dir = os.path.dirname(os.path.abspath(__file__))
        report_path = os.path.join(script_dir, "previsionielaborate.txt")
        numeri_decimali = []
        for chiave in sorted(self.carrelli.keys()):
            sequenza_binaria = ''.join(self.carrelli[chiave])
            numero_decimale = str(int(sequenza_binaria, 2))
            numeri_decimali.append(numero_decimale)
            logger.log(f"{chiave}.txt: {numero_decimale} (binario: {sequenza_binaria} = {int(sequenza_binaria, 2)})")
        with open(report_path, 'a', encoding='utf-8') as report:
            if self.ruota_corrente and numeri_decimali:
                report.write(f"{self.ruota_corrente} {'-'.join(numeri_decimali)}\n")
        logger.log("=====================")
        logger.log(f"Report salvato in: {report_path}")

def decimale_a_binario(decimale):
    return '.'.join(format(int(decimale), '07b'))

def converte_file_decimale(file_decimale, cartella_output, logger):
    colonne = []
    with open(file_decimale, 'r') as file:
        for linea in file:
            valori = linea.strip().split('.')
            for i, valore in enumerate(valori):
                if len(colonne) <= i:
                    colonne.append([])
                colonne[i].append(decimale_a_binario(valore))
    file_binari = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{i + 1}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_binari.append(nome_file)
        logger.log(f"File binario generato: {nome_file}")
    return file_binari

def split_file_binario(file_binario, cartella_output, logger):
    base_name = os.path.basename(file_binario)
    numero_file = ''.join(filter(str.isdigit, base_name.split('.')[0]))
    with open(file_binario, 'r') as file:
        righe = [line.strip().split('.') for line in file]
        colonne = list(zip(*righe))
    file_splittati = []
    for i, colonna in enumerate(colonne):
        nome_file = os.path.join(cartella_output, f"b{numero_file}-{i}.txt")
        with open(nome_file, 'w') as file:
            file.write('\n'.join(colonna))
        file_splittati.append(nome_file)
        logger.log(f"File splittato generato: {nome_file}")
    return file_splittati

def carica_dati(file_path):
    with open(file_path, 'r') as file:
        # Legge i dati e INVERTE l'ordine per avere i più vecchi in alto durante l'analisi
        dati = [bit for line in file for bit in line.strip().split('.')]
        return dati[::-1]  # <-- Modifica chiave qui

def analizza_file(file_binario, lunghezza_sequenza, carrello, logger, report_ottimali, file_estrazioni,
                  soglia_minima, analisi_automatica):
    posizione = int(os.path.basename(file_binario).split('-')[1].split('.')[0])
    dati = carica_dati(file_binario)  # Dati ora sono invertiti: [vecchio, ..., recente]

    logger.log(f"\nAnalisi pattern per {file_binario}")
    logger.log(f"Posizione bit analizzata: bit{posizione}.txt")
    logger.log(f"Lunghezza sequenza pattern: {lunghezza_sequenza}")

    # Controllo per assicurarsi che la lunghezza del pattern sia valida
    if lunghezza_sequenza <= 0:
        logger.log(f"Lunghezza sequenza pattern non valida: {lunghezza_sequenza}")
        return False

    # Pattern iniziale preso dalla FINE dei dati invertiti (corrisponde ai più RECENTI nel file originale)
    initial_pattern = tuple(dati[-lunghezza_sequenza:])  # <-- Modifica qui

    preceding_bits = []

    # Analizza dal basso (vecchio) verso l'alto (recente) nei dati invertiti
    for i in range(len(dati) - lunghezza_sequenza):
        current_window = tuple(dati[i:i + lunghezza_sequenza])
        if current_window == initial_pattern and i + lunghezza_sequenza < len(dati):
            # Il bit successivo è quello DOPO la finestra, verso l'alto (più recente)
            preceding_bit = dati[i + lunghezza_sequenza]
            preceding_bits.append(preceding_bit)

    count_0 = preceding_bits.count('0')
    count_1 = preceding_bits.count('1')
    total = len(preceding_bits)

    if total == 0:
        prob_0, prob_1 = 0.5, 0.5
    else:
        prob_0 = count_0 / total
        prob_1 = count_1 / total

    occ = {'0': count_0, '1': count_1}
    TOLLERANZA = 0.0001
    is_optimal = any(abs(prob - 1.0) < TOLLERANZA for prob in [prob_0, prob_1])

    # Controllo per identificare i casi con esattamente un bit inferiore alla soglia minima
    if analisi_automatica:
        bit_inferiori = [bit for bit in preceding_bits if (bit == '0' and prob_0 < soglia_minima / 100) or (bit == '1' and prob_1 < soglia_minima / 100)]
        if len(bit_inferiori) == 1:
            file_b = os.path.basename(file_binario).split('-')[0] + ".txt"
            report_ottimali.aggiungi_caso(
                os.path.basename(file_estrazioni),
                file_b,
                posizione,
                prob_0,
                prob_1
            )
            return True

    valore_predetto = '0' if prob_0 > prob_1 else '1'
    prob_valore = prob_0 if valore_predetto == '0' else prob_1

    logger.log(f"Sequenza iniziale: {''.join(initial_pattern)}")
    logger.log(f"Occorrenze trovate del pattern: {total}")
    logger.log(f"Probabilità '0': {prob_0:.2%} (occorrenze: {count_0})")
    logger.log(f"Probabilità '1': {prob_1:.2%} (occorrenze: {count_1})")
    logger.log(f"Valore predetto: {valore_predetto} (probabilità: {prob_valore:.2%})")

    carrello.aggiungi_predizione(file_binario, posizione, valore_predetto)

    # Aggiunto controllo per fermarsi se tutte le probabilità sono maggiori o uguali alla soglia
    if prob_0 >= soglia_minima / 100 and prob_1 >= soglia_minima / 100:
        return True

    return is_optimal

def processo_automatico(file_input, lunghezza_sequenza, righe_da_analizzare=10000, soglia_minima=100, analisi_automatica=False):
    cartella_output = os.path.dirname(os.path.abspath(file_input))
    nome_file = os.path.basename(file_input)
    logger = Logger(cartella_output)
    report_ottimali = ReportCasiOttimali(cartella_output)
    report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
    report_ruote_non_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTENONOTTIMALI.txt")
    logger.log(f"Inizio elaborazione")
    logger.log(f"File input: {nome_file}")
    logger.log(f"Cartella output: {cartella_output}")
    logger.log(f"Lunghezza sequenza: {lunghezza_sequenza}")
    logger.log(f"Righe da analizzare: {righe_da_analizzare}")
    logger.log(f"Soglia minima: {soglia_minima}%")
    logger.log("\nConversione file decimale in binari...")

    with open(file_input, 'r') as file:
        lines = []
        for i, line in enumerate(file):
            if i < righe_da_analizzare:
                lines.append(line)
            else:
                break

    temp_file = os.path.join(cartella_output, "temp_estrazioni.txt")
    with open(temp_file, 'w') as file:
        file.writelines(lines)

    file_binari = converte_file_decimale(temp_file, cartella_output, logger)
    carrello = CarrelloPredizioni()
    carrello.set_ruota(nome_file)
    is_ruota_ottimale = True

    for file_binario in file_binari:
        logger.log(f"\nElaborazione {os.path.basename(file_binario)}...")
        file_splittati = split_file_binario(file_binario, cartella_output, logger)
        for file_splittato in file_splittati:
            if not analizza_file(file_splittato, lunghezza_sequenza, carrello, logger, report_ottimali, nome_file, soglia_minima, analisi_automatica):
                is_ruota_ottimale = False

    if is_ruota_ottimale:
        report_ruote_ottimali.aggiungi_ruota(carrello.ruota_corrente)
    else:
        report_ruote_non_ottimali.aggiungi_ruota(carrello.ruota_corrente)

    carrello.mostra_risultati(logger, cartella_output)
    report_ottimali.finalizza_report()
    tempo_totale = logger.tempo_totale()
    logger.log(f"\nTempo totale di elaborazione: {tempo_totale}")
    logger.log(f"Report casi ottimali salvato in: {report_ottimali.report_path}")
    logger.log(f"Report ruote ottimali salvato in: {report_ruote_ottimali.report_path}")
    logger.log(f"Report ruote non ottimali salvato in: {report_ruote_non_ottimali.report_path}")

    os.remove(temp_file)

    return report_ottimali.casi_trovati

def ottieni_percorso_file_estrazioni(ruota):
    return os.path.join(ruota, f"estrazioni-{ruota}.txt")

def inizializza_report_ruote():
    script_dir = os.path.dirname(os.path.abspath(__file__))
    for nome_file in ["RUOTEOTTIMALI.txt", "RUOTENONOTTIMALI.txt"]:
        report_path = os.path.join(script_dir, nome_file)
        with open(report_path, 'w', encoding='utf-8') as f:
            f.write(f"=== {nome_file.replace('.txt', '').upper()} ===\n\n")

def main():
    root = Tk()
    root.title("Seleziona Ruote")

    pattern_frame = Frame(root)
    pattern_frame.pack(pady=10)
    Label(pattern_frame, text="Lunghezza pattern:").pack(side='left')
    pattern_length = Entry(pattern_frame, width=5)
    pattern_length.insert(0, "18")
    pattern_length.pack(side='left', padx=5)

    righe_frame = Frame(root)
    righe_frame.pack(pady=10)
    Label(righe_frame, text="Prime righe da analizzare:").pack(side='left')
    righe_da_analizzare = Entry(righe_frame, width=5)
    righe_da_analizzare.insert(0, "10000")
    righe_da_analizzare.pack(side='left', padx=5)

    soglia_frame = Frame(root)
    soglia_frame.pack(pady=10)
    Label(soglia_frame, text="Soglia minima di probabilità (%):").pack(side='left')
    soglia_minima = Entry(soglia_frame, width=5)
    soglia_minima.insert(0, "100")
    soglia_minima.pack(side='left', padx=5)

    analisi_automatica_var = IntVar()
    Checkbutton(root, text="Analisi e selezione automatica", variable=analisi_automatica_var).pack(pady=5)

    Label(root, text="Seleziona le ruote da analizzare:").pack()

    ruote = ["BA", "CA", "FI", "GE", "MI", "NA", "PA", "RO", "TO", "VE", "NZ"]
    ruote_vars = {ruota: IntVar() for ruota in ruote}

    checkbuttons_frame = Frame(root)
    checkbuttons_frame.pack(pady=5)

    for ruota in ruote:
        Checkbutton(checkbuttons_frame, text=ruota, variable=ruote_vars[ruota]).pack(anchor='w')

    buttons_frame = Frame(root)
    buttons_frame.pack(pady=10)

    def seleziona_tutto():
        for var in ruote_vars.values():
            var.set(1)

    def deseleziona_tutto():
        for var in ruote_vars.values():
            var.set(0)

    def analizza():
        try:
            lunghezza_seq = int(pattern_length.get())
            righe = int(righe_da_analizzare.get())
            soglia = float(soglia_minima.get())
            analisi_automatica = analisi_automatica_var.get()
            ruote_selezionate = [ruota for ruota, var in ruote_vars.items() if var.get()]

            inizializza_report_ruote()

            if analisi_automatica:
                lunghezza_seq_iniziale = lunghezza_seq
                while True:
                    casi_trovati = False
                    for ruota in ruote_selezionate:
                        file_input = ottieni_percorso_file_estrazioni(ruota)
                        if os.path.exists(file_input):
                            logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                            logger.log(f"Analizzando ruota: {ruota}")
                            logger.log(f"File input: {file_input}")
                            logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                            logger.log(f"Righe da analizzare: {righe}")
                            logger.log(f"Soglia minima: {soglia}%")
                            if processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica):
                                casi_trovati = True
                                logger.log(f"Ruota ottimale trovata: {ruota}")
                                report_ruote_ottimali = ReportRuote(os.path.dirname(os.path.abspath(__file__)), "RUOTEOTTIMALI.txt")
                                report_ruote_ottimali.aggiungi_ruota(f"RUOTA OTTIMALE: {ruota}")
                                winsound.Beep(1000, 2000)  # Emette un bip sonoro a 1000 Hz per 2 secondi
                                break
                    if casi_trovati:
                        break
                    lunghezza_seq += 1
                    logger.log(f"Aumentando la lunghezza del pattern a {lunghezza_seq}")
            else:
                for ruota in ruote_selezionate:
                    file_input = ottieni_percorso_file_estrazioni(ruota)
                    if os.path.exists(file_input):
                        logger = Logger(os.path.dirname(os.path.abspath(file_input)))
                        logger.log(f"Analizzando ruota: {ruota}")
                        logger.log(f"File input: {file_input}")
                        logger.log(f"Lunghezza sequenza: {lunghezza_seq}")
                        logger.log(f"Righe da analizzare: {righe}")
                        logger.log(f"Soglia minima: {soglia}%")
                        processo_automatico(file_input, lunghezza_seq, righe, soglia, analisi_automatica)
                    else:
                        print(f"File di estrazioni per la ruota {ruota} non trovato.")
        except ValueError:
            print("Errore: inserire valori numerici validi.")

    Button(buttons_frame, text="Seleziona Tutto", command=seleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Deseleziona Tutto", command=deseleziona_tutto).pack(side='left', padx=5)
    Button(buttons_frame, text="Analizza", command=analizza).pack(side='left', padx=5)

    root.mainloop()

if __name__ == "__main__":
    main()

Per testarlo, e magari contribuire alla sua ottimizzazione e/o correzione, è necessario creare 11 cartelle : BA , CA , FI ecc... fino a NZ con dentro i rispettivi file estrazioni-BA.txt ecc... contenenti ognuno le estrazioni della rispettiva ruota con la prima estrazione in alto e l'ultima in basso in formato con i 5 estratti a doppia cifra (i numeri da 1 a 9 con lo 0 davanti) intervallata da carattere punto (es. 01.88.77.32.05). AI utilizzate per adesso per questo script py: Claude Sonnet 3.5, DeepSeek, ChatGpt e Mistral. Selezionando "Analizza e seleziona automaticamente" lo script continuerà la ricerca ad libitum aumentando la lunghezza del pattern iniziale di una unità ad ogni nuovo ciclo.. Per adesso lo script si potrà interrompere solo bruscamente.. con ctrl + s (pausa) e ctrl + q (prosegui) o con ctrl + c (chiudi) o chiudendo direttamente la finestra dos. Per ovviare a questo comunque basta comunque implementarvi un bottone per chiuderlo in modo + dolce... o non selezionare quell'opzione di analisi automatica... :)

breve schema e spiegazione dell'idea di base che ho avuto e che mi ha spinto a voler cercare di realizzare questo script :

la sequenza di estratti di ogni estrazione e per ogni ruota viene convertita in rispettivi numeri binari a 7 bit i quali vengono a loro volta scomposti nelle 7 colonne di bit (da bit0 a bit6). Queste 7 colonne vengono analizzate una ad una a partire dal basso verso l'alto dopo che è stato costruito un pattern spia di ricerca prelevando i primi elementi di ciascuna colonna a partire dall'alto. Questa operazione si può fare sia staticamente scegliendo una lunghezza fissa sia dinamicamente lasciando appunto allo script di aumentare ad ogni ciclo la lunghezza del pattern di partenza... Lo script dovrà quindi annotarsi tutte le quantità di 0 e di 1 che incontrerà per ciascuna colonna di bit dopo la sequenza del pattern di ricerca e in base alla loro presenza maggiore e quindi relativa probabilità di apparizione ipotizzare quale ci sarà dopo l'ultimo bit in alto della rispettiva colonna analizzata... Per far questo è possibile scegliere statisticamente una % minima di presenza per far si che il bit che la raggiunge o supera sia considerato + probabile dell'altro.



Vedi l'allegato 2296926
Clicca per espandere...
Ciao lotto_tom75 ho un piccolo dubbio, allora l'estrazione ultima del 15/02 andrebbe posizionata in basso nell' archivio e su su a salire quelle piu' vecchie ? Grazie
 
Silvix ha scritto:
Ciao lotto

Ciao lotto_tom75 ho un piccolo dubbio, allora l'estrazione ultima del 15/02 andrebbe posizionata in basso nell' archivio e su su a salire quelle piu' vecchie ? Grazie
Clicca per espandere...

No esattamente l'opposto... ma in realtà se ne occupa lo script .ls e .py di posizionare sia le estrazioni (.ls) che i relativi bit (.py) nell'ordine giusto (in alto le recenti e in basso le + vecchie).
 
Aggiornamento: sostituito blenderbot (lentissimo su pc senza gpu) con granite (interscambiabilità dei modelli da ottimizzare ma funzionante...). Granite nella versione 1B 2 gb ca è velocissimo e reattivo anche su pc senza gpu nvidia come il mio :). Se trovo il modo di addestrarlo anche sul lotto... ne vedremo delle belle... :)

implementazione-di-granite-1B-ai-veloceanchesupcsenzagpu.jpg
 
lotto_tom75 ha scritto:
... Se trovo il modo di addestrarlo anche sul lotto... ne vedremo delle belle... :)
Clicca per espandere...


🤠 A proposito di granite 1b e modelli small similari sai come potrei addestrarlo su argomenti specifici come lotto, statistiche, analisi di grafici ecc...?

🤖 ChatGPT ha detto:​

Per addestrare Granite 1B (o modelli simili) su argomenti specifici come il Lotto, la statistica e l’analisi grafica, hai tre approcci principali, considerando il tuo hardware limitato:

1. Fine-tuning completo (non consigliato per il tuo hardware)​

  • Richiede una GPU potente o molte CPU e RAM.
  • Usa dataset specifici per specializzare il modello.
  • Tool: Hugging Face Transformers, PyTorch, Deepspeed.

2. Adattamento con LoRA (Leggero e possibile per hardware limitato)​

  • Utilizza una rete di adattamento per specializzare il modello.
  • Più efficiente perché modifica solo una piccola parte dei pesi.
  • Tool: peft (Hugging Face), bitsandbytes.

3. Addestramento tramite Prompt Engineering e RAG (Il più semplice per te)​

  • Non modifica il modello, ma gli fornisce dati mirati durante l’uso.
  • Usa documenti/testi di riferimento da cui il modello attinge risposte.
  • Strumenti: LangChain per implementare un Retrieval-Augmented Generation (RAG).

Quale metodo scegliere?​

  • Se vuoi un'ottimizzazione ultra-leggera → Prompt Engineering + RAG.
  • Se vuoi un modello leggermente più specializzato → LoRA.
  • Se vuoi un modello completamente personalizzato (ma hai hardware limitato) → Non consigliato.

    Coming soon... 🤖🤠

Trovato questo mega video corso free di +6 ore per chi interessasse conoscere / approfondire il 🐍🧙‍♂️...

Un sistema a dir poco "fantastico" a parer mio di studiare qualsiasi cosa... e quindi anche questo video corso è utilizzare googlenotebooklm una AI "verticale" total free capace di riassumere e analizzare qualsiasi fonte (ne puoi caricare max 300 alla volta... di vario tipo come pdf, txt, link, url video ecc...).

Ecco ad esempio come ha capito e riassunto in pochissimi secondi di cosa tratta il video sopra condiviso semplicemente incollandogli l'url relativo come fonte :) . La figata massima è che puoi poi "parlare" con la fonte stessa tramite l'AI notebooklm. E questa è solo una delle molte funzioni di questa AI free "verticale". Per dirne solo un'altra è capace di trasformare qualsiasi fonte in podcast colloquiale tra due o più intervistati ai in modo da poterla anche ascoltare e acquisire come new know how o x svago mentre stai facendo altro (es. palestra ecc..).

forsenontutticonoscononotebookgooglelm.jpg
 
Ultima modifica:
lotto_tom75 ha scritto:
🤠 A proposito di granite 1b e modelli small similari sai come potrei addestrarlo su argomenti specifici come lotto, statistiche, analisi di grafici ecc...?

🤖 ChatGPT ha detto:​

Per addestrare Granite 1B (o modelli simili) su argomenti specifici come il Lotto, la statistica e l’analisi grafica, hai tre approcci principali, considerando il tuo hardware limitato:

1. Fine-tuning completo (non consigliato per il tuo hardware)​

  • Richiede una GPU potente o molte CPU e RAM.
  • Usa dataset specifici per specializzare il modello.
  • Tool: Hugging Face Transformers, PyTorch, Deepspeed.

2. Adattamento con LoRA (Leggero e possibile per hardware limitato)​

  • Utilizza una rete di adattamento per specializzare il modello.
  • Più efficiente perché modifica solo una piccola parte dei pesi.
  • Tool: peft (Hugging Face), bitsandbytes.

3. Addestramento tramite Prompt Engineering e RAG (Il più semplice per te)​

  • Non modifica il modello, ma gli fornisce dati mirati durante l’uso.
  • Usa documenti/testi di riferimento da cui il modello attinge risposte.
  • Strumenti: LangChain per implementare un Retrieval-Augmented Generation (RAG).

Quale metodo scegliere?​

  • Se vuoi un'ottimizzazione ultra-leggera → Prompt Engineering + RAG.
  • Se vuoi un modello leggermente più specializzato → LoRA.
  • Se vuoi un modello completamente personalizzato (ma hai hardware limitato) → Non consigliato.

    Coming soon... 🤖🤠

Trovato questo mega video corso free di +6 ore per chi interessasse conoscere / approfondire il 🐍🧙‍♂️...

Un sistema a dir poco "fantastico" a parer mio di studiare qualsiasi cosa... e quindi anche questo video corso è utilizzare googlenotebooklm una AI "verticale" total free capace di riassumere e analizzare qualsiasi fonte (ne puoi caricare max 300 alla volta... di vario tipo come pdf, txt, link, url video ecc...).

Ecco ad esempio come ha capito e riassunto in pochissimi secondi di cosa tratta il video sopra condiviso semplicemente incollandogli l'url relativo come fonte :) . La figata massima è che puoi poi "parlare" con la fonte stessa tramite l'AI notebooklm. E questa è solo una delle molte funzioni di questa AI free "verticale". Per dirne solo un'altra è capace di trasformare qualsiasi fonte in podcast colloquiale tra due o più intervistati ai in modo da poterla anche ascoltare e acquisire come new know how o x svago mentre stai facendo altro (es. palestra ecc..).

Vedi l'allegato 2297911
Clicca per espandere...
molto interessante per approfondire ed iniziare qualcosa di nuovo ,gli anni a venire lo vedranno grande protagonista python : lo è già di fatto; in tutti i sensi, ma poco apprezzato almeno da noi in Italia .Nel paese del sol levante è praticamente quotidiano l'uso e gli applicativi generati con python sono miliardi ,se pensiamo solo alle generazioni di nuovi applicativi che mondo affascinante. Grazie Tom per la condivisione di questo splendido corso che va seguito anche se non si è interessati allo sviluppo ,il futuro nel lavoro e la semplificazione di fatto in tutti i settori .Le nuove figure professionali sono super richieste a tutti i livelli .Buona giornata..Python
 
Devi accedere o registrarti per poter rispondere.

Ultima estrazione Lotto

  • Estrazione del lotto
    venerdì 21 febbraio 2025
    Bari
    66
    48
    65
    47
    75
    Cagliari
    20
    66
    90
    31
    86
    Firenze
    54
    01
    37
    47
    04
    Genova
    81
    70
    67
    24
    80
    Milano
    53
    49
    75
    43
    45
    Napoli
    45
    59
    25
    43
    79
    Palermo
    28
    14
    02
    11
    89
    Roma
    45
    44
    82
    07
    84
    Torino
    88
    72
    43
    61
    02
    Venezia
    46
    70
    45
    39
    72
    Nazionale
    33
    03
    26
    76
    66
    Estrazione Simbolotto
    Cagliari
    16
    06
    30
    32
    07
    Archivio estrazioni lotto Ritardi top 15 Frequenze top 15

Ultimi Messaggi

Indietro
Alto