Programmazione genetica [chiuso]

Recentemente stavo navigando su Reddit e mi sono imbattuto in un post che collega un esempio di "algoritmo genetico JavaScript". Sono stato davvero affascinato dai concetti di algoritmi genetici e programmazione, tuttavia, anche dopo aver cercato su Google, sono ancora leggermente confuso. Come funziona?

Suppongo che i termini del vocabolario mi confondano più di ogni altra cosa. Gradirei brevi esempi e forse spiegazioni. Solo il concetto di programmazione genetica e come potrei implementarlo nei miei progetti e perché?

Sembra che tu stia parlando di algoritmi genetici più che di programmazione genetica, ma ecco il mio contributo alla tua comprensione.

Può essere utile pensare alle GA in termini di parti di cui sono composte.

Quindi supponiamo che tu abbia qualche tipo di problema. La prima cosa di cui hai bisogno è un modo per esprimere l'aspetto di una soluzione. Se hai avuto un problema con un commesso viaggiatore con le città A, B, C, D, E, allora sai già come potrebbe essere una soluzione, una serie di nomi delle città [B, C, A, D, E].

Questo è il gene .

Altrimenti noto come una potenziale soluzione al problema. Come menziona Steven A. Lowe, le stringhe di bit sono un modo comune per codificare i geni, ma non è necessario; semplifica solo alcune cose. La parte importante è che hai un modo per rappresentare una soluzione in questo modo simile a un array.

Adesso. Come fai a sapere se la soluzione è buona? È necessaria una funzione in grado di dirti e valutare la soluzione. Quindi, sempre per TSP potresti avere una funzione che misura la distanza percorsa usando il percorso [B, C, A, D, E]. Il "voto" che assegni potrebbe essere semplicemente la distanza percorsa ma in problemi più complicati potresti includere cose come il costo del viaggio e altre cose.

Questa è la funzione fitness .

Quindi ora puoi prendere una potenziale soluzione e scoprire se è buona. Qual è il prossimo?

Quindi dobbiamo iniziare la nostra prima generazione. Quindi generiamo un sacco di soluzioni casuali. Non importa se sono buoni o no. Questa è la tua popolazione iniziale o seme. Puoi chiamarlo il tuo pool genetico.

Quindi prendi il tuo pool genico iniziale e applichi la tua funzione di fitness a tutti loro e dai loro un voto. Ora devi prenderne due e creare una nuova popolazione da loro - per la prossima generazione. Chi selezioni? Beh, non vuoi necessariamente selezionare solo il più adatto della misura, che può portare ad alcuni problemi. Invece hai bisogno di una funzione di selezione .

Un modo per selezionare che è facile da visualizzare è usare una sorta di ruota: ogni gene è una fetta su una ruota e il loro punteggio di fitness indica quanto è grande la loro fetta (migliore è la forma, maggiore è la fetta). Metti un perno che punta alla ruota e dagli un giro (cioè genera un numero casuale). Il pin punta al primo genitore. Fallo di nuovo per il secondo genitore.

Ora devi creare nuovi bambini. Vuoi unire i genitori per produrre una nuova popolazione. Esistono vari modi per farlo, ma sono tutti chiamati funzione crossover . Puoi dividerli a metà e scambiare le metà tra i genitori, o fare una sorta di interfogliatura. Questo è molto analogo ai genitori di mammiferi che producono nuovi bambini -> entrambi contribuiscono con i loro geni al nuovo bambino.

Una volta che hai questa nuova generazione, lanci una mutazione casuale, ma rara , per ogni bambino. Ho visto spesso tassi di mutazione che si verificano a meno dell'1%. La funzione di mutazione cambierà casualmente qualcosa nel tuo gene codificato. Se il tuo gene è un po 'di stringa, potrebbe scambiarsi un po', se è un array di città, potrebbe scambiare 2 città nell'elenco. La parte importante è che è un evento relativamente raro e mescola le cose.

Ripeti questo processo fino a un numero desiderato di generazioni o fino a quando la tua funzione di fitness non produce genitori con punteggi di fitness costantemente elevati e hai una soluzione che (si spera, se hai fatto tutto bene) è ottimale.

Era un po 'prolisso, quindi vorrei riassumere con una metafora:

1. I geni sono persone: le persone risolvono i problemi
2. Le funzioni di fitness sono classifiche: le persone ottengono un voto in base alla capacità di risolvere un problema
3. Selezionate 2 persone per generare una nuova popolazione: date alle persone con voti migliori maggiori possibilità di riproduzione
4. Quando i genitori si riproducono, si uniscono per produrre figli.
5. Raramente e casualmente muti i loro figli
6. Classifichi i bambini della nuova popolazione
7. Risciacqua e ripeti

Spero che sia di aiuto.

codificare una soluzione a un problema come una stringa di bit

scrivere una funzione (chiamata funzione "fitness") che valuta quanto "buona" viene data una stringa di bit alla soluzione codificata - il risultato è di solito un numero compreso tra 0 e 1

genera casualmente un mucchio di queste stringhe di bit e ne valuta l'idoneità

scegli alcuni dei gruppi, in genere quelli più adatti, e tagliali a metà e scambia le metà per creare alcune nuove stringhe di bit (crossover)

quindi a volte capovolgi casualmente alcuni bit in alcune delle nuove stringhe di bit (mutazione)

ripetere fino a quando non si evolve una buona soluzione

perché farlo: alcuni problemi hanno enormi spazi di soluzione possibili, così grandi che la valutazione di tutte le possibilità è impraticabile (vedi Problema del commesso viaggiatore)

Consiglio vivamente il libro Algoritmi genetici in ricerca, ottimizzazione e apprendimento automatico

La programmazione genetica è un modo per far scrivere al computer programmi per te!

Non pensare a "programmi" come MS Word, pensa a "programmi" come segue:

function(x){ return x*2; }

Questa funzione (o programma), da sola, non ha motivo di esistere. Siamo alla ricerca di soluzioni ai problemi. Se hai bisogno di trovare la somma di due numeri, devi solo aprire la calcolatrice e fare i conti. Che cosa succede se qualcuno ti fornisse la seguente tabella e ti chiedesse di capire la relazione tra resulte xe y:

x   y   result
99  1   (3.02)
79  88   2.01 
21  62   5.01 
84  52  (6.58)
12  70   5.54 
67  18   0.73 

Questi dati sono i tuoi dati di "allenamento". Il tuo computer utilizzerà questi dati per generare alcune ipotesi, quindi lo testerai con dati reali.

Supponi che non conosci le statistiche e decidi che questo problema è troppo difficile da capire da solo, quindi otterrai il computer per capirlo.

Chiedi al computer di generare casualmente ipotesi selvagge

Hai il computer che genera un milione di risposte e vedi se qualcuno di loro si attacca (indovina ... un milione di volte!). Di seguito è riportato un esempio di un paio di ipotesi:

function(x,y){ return x+y; } // wrong
function(x,y){ return x/1*1*1*1*1*1+y; } //wrong, silly

Potresti saperlo o meno, ma funzioni o programmi possono anche essere rappresentati come alberi, ad esempio la seconda funzione sarebbe:

(+ (/ x (* 1 (* 1 (* 1 (* 1 (* 1 1)))) y)

Puoi farlo sembrare più simile a un albero indentandolo in questo modo (tra l'altro, cerca la notazione polacca inversa e la sintassi lisp ... ma capirai perché rappresenteremo programmi come questo a breve):

(+ 
    (/ x 
        (* 1 
            (* 1 
                (* 1 
                    (* 1 
                        (* 1 1)))) 
    y)

( +è in cima con due "foglie" di /e y. /stesso ha diversi figli, ecc.)

Ecco perché leggi così tanto sugli "alberi" nella programmazione genetica. In ogni caso, inseriamo i valori di xe yin questa funzione e ci dà la risposta ERRATA. Non sorprende però dal momento che abbiamo generato casualmente questo.

Ora decidi di generare un milione di tali soluzioni. Tutti hanno torto. Tuttavia, noti che alcune risposte sono più vicine alla risposta giusta di altre. In altre parole, alcune soluzioni sono più "adatte" di altre. Si noti che il computer non sa cosa sia "giusto" e "sbagliato", quindi è necessario fornire la propria "funzione di fitness". Questa funzione riceve una potenziale soluzione, i dati di allenamento, ed è responsabile di dire al sistema GP quanto "si adatta" questa soluzione. Come puoi immaginare, questa funzione viene eseguita milioni e milioni di volte.

Ciò che rende GP diverso

Ecco cosa rende la programmazione genetica diversa dalle ipotesi selvagge. Decidi di fare un altro giro di milioni di ipotesi; tuttavia, lo fai in modo un po 'più intelligente. Prendi il 10% superiore delle ipotesi (quelle che erano chiuse ai valori reali) e le rendi parte della seconda generazione. Prendi anche molte di queste soluzioni (forse lo stesso 10% ... non ricordo) e decidi di "mescolarle".

Scegli casualmente due soluzioni, scegli casualmente sotto-alberi e inizi a scambiarli. Quindi parte della soluzione A finisce sotto la soluzione B e viceversa: li hai semplicemente "incrociati". Prendi anche alcune soluzioni e semplicemente le "muti" ... prendi un po 'di sottostruttura e "rovinala" un po' (ehi, se la soluzione è terribile, "rovinarla senza motivo" potrebbe effettivamente migliorarla).

Un buon modo di pensare a questo è il seguente: tua mamma e tuo papà hanno determinati attributi: colore dei capelli, altezza, probabilità di malattia, ecc. Tu, come bambino, erediti attributi diversi da entrambi i tuoi genitori. Se entrambi i tuoi genitori fossero atleti olimpici, sarai anche un super atleta, giusto? Bene, biologi, sociologi e persino storici potrebbero contestare questa idea, ma gli informatici non si preoccupano della moralità dell'eugenetica qui. Hanno appena visto un "sistema" fare un ottimo lavoro fornendo soluzioni, quindi hanno deciso di modellarlo nel software.

Se in realtà non corrisponde alla biologia, ma fornisce comunque buone risposte ... molti scienziati informatici dicono collettivamente "qualunque tipo, e grazie per la terminologia". Nota anche che tutti i tuoi fratelli e sorelle e non ESATTAMENTE lo stesso ... anche se hanno gli stessi genitori. Ogni persona ha geni che mutano per qualsiasi motivo (per favore non mostrarlo a un biologo, il punto è capire la motivazione dietro gran parte della terminologia).

Quindi ora stiamo facendo in modo che il computer generi milioni di programmi e ne misuriamo l'idoneità. Le migliori soluzioni sopravvivono alla generazione successiva. Inoltre "mutiamo" e facciamo il cross-over sulla "popolazione" (notate come viene usato il linguaggio della genetica e della biologia). Una volta creata la seconda generazione, la forma fisica viene nuovamente misurata. Poiché questa generazione ha le migliori soluzioni della generazione precedente E abbiamo incrociato e mutato le migliori soluzioni (insieme alla popolazione mediocre - per mantenere la diversità), questa generazione dovrebbe essere almeno un po 'migliore della generazione precedente.

Lo continuiamo per un numero molto elevato di generazioni. Ogni generazione (si spera) fornisce soluzioni sempre migliori, fino a quando non avremo la risposta giusta. Per esempio:

(+ (- 2.2 (/ x 11) (* 7 (cos y))))

Bene guarda questo, questo è corretto!
(L'ho copiato da http://en.wikipedia.org/wiki/Genetic_programming , che ha anche una rappresentazione grafica di questo albero)

Cianfrusaglie

Ci sono alcuni problemi importanti, come come decidere quali "terminali" ( +, -, *, /, cos, sin, tan) sono disponibili per il proprio sistema GP, come si scrive la funzione fitness e come il sistema gestisce programmi non sensitivi come (1 + cos)o (2 / "hello")(tra molti altri).

È abbastanza noioso evolvere le equazioni. Diventa più interessante se il tuo set di terminali è simile al seguente: (fuoco, rileva il nemico, muoviti, ...) e la tua funzione di fitness misura la tua salute e il numero di cadaveri di mostri marziali.

Ho scritto la maggior parte di questo dalla memoria, ma questa è l'idea di base. Ho fatto qualche GP negli anni del college. Dovresti assolutamente giocarci. Non preoccuparti di comprendere tutta la terminologia, scarica solo alcuni sistemi GP gratuiti, scorri alcuni esempi per farti un'idea e crea i tuoi esempi interessanti (trova relazioni tra diversi set di dati, prova a collegarlo al gioco API, ecc.)

Survival of the Fittest: Natural Selection with Windows Forms è stato il modo in cui sono stato introdotto alla programmazione genetica. È facile da leggere con il codice disponibile per il download. Il rovescio della medaglia è che GP richiede un mezzo per eseguire il codice creato in fase di esecuzione e al momento in cui l'articolo è stato scritto, C # non era adatto a questo compito. Questo è il motivo per cui l'esempio utilizza CodeDOM per generare, compilare ed eseguire il codice in fase di esecuzione, il che da solo aggiunge un ulteriore livello di complessità.

Le cose sono cambiate da allora con .NET che ora ha un'API ExpressionTree propria, che probabilmente consentirebbe un'implementazione GP più elegante in C # rispetto a quella descritta nell'articolo. Ma è abbastanza buono per capire come funziona il GP.

Qui puoi scaricare un ebook gratuito su GP, che include anche un breve esempio di codice java che potresti trovare interessante.

Gli algoritmi genetici e la programmazione genetica sono correlati, ma concetti diversi.

Gli algoritmi genetici (GA) sono algoritmi di ricerca per problemi di ottimizzazione complessi. In un GA, si codificano i parametri di una soluzione a qualche problema in una stringa di bit "DNA", quindi "si riproducono" casualmente queste stringhe: farle riprodurre combinando parti di esse e applicare la "sopravvivenza del più adatto" eliminando tutte le stringhe hai tranne quelli che sono i migliori nel risolvere il tuo problema.

La programmazione genetica (GP) è ancora più complicata: qui, non si rappresentano i programmi dal loro DNA (stringhe di bit), ma dagli alberi di analisi che si allevano e si selezionano.