[C - PHP o altro] Creazione codice autogenerante e modificante

[$te]

Come da titolo: creare un programma, che poi puo modificarsi.

L'idea m'é venuta dopo che ho visto un documentario, in cui avevano fatto un esperimento:
avevano creato dei piccoli robottini, ed ognuno aveva un algoritmo, che serviva per "cercare" il cibo (che non era altro che un carica batterie). Quindi questi robottini, ognuno con un algoritmo diverso, si muovevano finché non trovavano questo cibo. Poi, ogni volta, questi programmatori prendevano l'algoritmo dei "migliori" e lo incrociavano, finché, dopo svariati incroci, si arrivava ad un robottino piu efficace e veloce della prima generazione.

Come creare qualcosa di "simile" (a grandissime linee, non voglio certo essere presuntuoso), in modo che l'incrocio di "dna" avvenga in automatico.



Spero mi sia spiegato bene...

grazie

[$te]

ho esagerato con la richiesta?

[nikel]

facendo un esempio...

hai i tuoi codici, che devono essere divisi in "blocchi" di modo che:

codice robot1:

blocco1 = funzione1 (che può essere il calcolo del percorso più breve)
blocco2 = funzione2 (che può essere l'analisi dell ambiente per cercare il carica batterie)

codice robot2:

blocco1 = funzione1 (ma con algoritmo diverso)
blocco2 = funzione2 (con algoritmo diverso)

--------------------------------

ogni blocco deve quindi svolgere la stessa funzione in ogni codice...

a questo punto elabori un codice centrale che dati i tuoi parametri verifichi quale dei due blocchi ha eseguito meglio la stessa funzione...

non resta che unire i blocchi migliori per ricreare un codice migliore e ricompilarlo...

è solo un idea ma penso che possa funzionare!

[yorkeiser]

Da antichi (e incrostati) ricordi di intelligenza artificiale, mi pare di ricordare che per codice automodificante si intende qualcosa di diverso e viene scritto a basso livello (virus e algoritmi di protezione soprattutto), te invece mi pare stia parlando di un altro campo, ovvero di algoritmi genetici.
Si tratta sostanzialmente di ottenere un modello piuttosto lineare dell'algoritmo utilizzato da un determinato elemento della specie (programma di controllo + coefficienti), ad esempio un array di n interi, oppure una stringa di char, o altro, che modellano il comportamento di quel dato elemento della specie.
Si prendono n elementi di una determinata specie (ad esempio, n threads che istanziano una classe differenziandosi solo per la struttura dati che contiene i coefficienti) e li si pone di fronte ad un problema.
Quindi, in base alla percentuale di successo nella risoluzione del problema, si tratta di costruire un nuovo elemento della specie (stesso programma di controllo, diversi coefficienti) che incroci i coefficienti di un certo numero di elementi "vincenti" (ad esempio, da due elementi vincenti, puoi costruire un figlio prendendo gli elementi dispari dell'array dei coefficienti dal primo e quelli pari dal secondo) e rimetterlo nel calderone. Descrizione molto sommaria e sbrigativa, c'è un mondo dietro.
Ma sostanzialmente, l'algoritmo che governa il singolo elemento della specie (e quindi il programma) a livello teorico resta lo stesso, quindi non è il codice a modificarsi: cambiano soltanto i coefficienti che ne determinano il comportamento (tecnicamente, si può fare banalmente, ad esempio, scrivendo i nuovi coefficienti su una tabella di un database e creando i figli a partire dal database stesso).

[$te]

Originariamente inviato da yorkeiser

Da antichi (e incrostati) ricordi di intelligenza artificiale, mi pare di ricordare che per codice automodificante si intende qualcosa di diverso e viene scritto a basso livello (virus e algoritmi di protezione soprattutto), te invece mi pare stia parlando di un altro campo, ovvero di algoritmi genetici.
Si tratta sostanzialmente di ottenere un modello piuttosto lineare dell'algoritmo utilizzato da un determinato elemento della specie (programma di controllo + coefficienti), ad esempio un array di n interi, oppure una stringa di char, o altro, che modellano il comportamento di quel dato elemento della specie.
Si prendono n elementi di una determinata specie (ad esempio, n threads che istanziano una classe differenziandosi solo per la struttura dati che contiene i coefficienti) e li si pone di fronte ad un problema.
Quindi, in base alla percentuale di successo nella risoluzione del problema, si tratta di costruire un nuovo elemento della specie (stesso programma di controllo, diversi coefficienti) che incroci i coefficienti di un certo numero di elementi "vincenti" (ad esempio, da due elementi vincenti, puoi costruire un figlio prendendo gli elementi dispari dell'array dei coefficienti dal primo e quelli pari dal secondo) e rimetterlo nel calderone. Descrizione molto sommaria e sbrigativa, c'è un mondo dietro.
Ma sostanzialmente, l'algoritmo che governa il singolo elemento della specie (e quindi il programma) a livello teorico resta lo stesso, quindi non è il codice a modificarsi: cambiano soltanto i coefficienti che ne determinano il comportamento (tecnicamente, si può fare banalmente, ad esempio, scrivendo i nuovi coefficienti su una tabella di un database e creando i figli a partire dal database stesso).

ho capito cosa vuoi dire (avevo pensato anche a questo), pero questo porta delle problematiche. In questo modo, devi definire da subito il tuo algoritmo (o il tuo bel programma), e, come dici te, modifichi solo i parametri (un po come le reti neuronali, con i vari pesi (giusto?).
Pero mi sembra che cosi non si "progredisce", capisci cosa intendo?

La mia idea era questa (faccio un paragone): é come definire inizialmente i 3 colori primari (che sono gli algoritmi), e poi da questi faccio tutti gli altri colori.

(Se fai un passo in piu, puoi intravedere la mia idea: creare un "cervello" da formica..per poi farlo "evolvere"....si lo so...sono ingenuo:P ma mi accontenterei della formica)

nikel: é proprio quello che pensavo, anche se non avevo pensato al fatto di avere, come nel tuo esempio, due blocchi che fanno la stessa cosa ma in modo diverso. Io l'avevo pensata piu cosi:

alg1: muoversi a destra, sinistra, su e giu
alg2: funzione random per decidere cosa fare
alg3: riconoscere i "muri"
-----
alg1: muoversi diagonalmente
alg2: funzione semi-random
alg3. etc


Poi incrociare, e gestire il tutto con una specie di funzione (fatta di if, while e for), per scegliere vari algoritmi.
Quindi, dopo tot generazioni, il robot ha piu algoritmi (non solo 3), o piu blocchi di algoritmi.

Stasera provo a scrivere qlc (se programmate in ambiente linux, mi sapreste aiutare anche in questo thread pf:P: http://www.hwupgrade.it/forum/showthread.php?t=2136988).

Grazie