Newsgroup: it.comp.ia
Titolo: Reti Neurali e Crittografia

Salve,
vorrei "accendere" un thread su di un argomento abbastanza complesso.
Io ed un mio compagno di corso ci siamo avventurati in una tesina di I.A.
(da noi stessi proposta) sulla crittografia con le reti neurali.
Abbiamo fatto una ricerca su DejaNews e abbiamo trovato qualche
informazione, ma questo settore delle NN e' in ogni caso poco esplorato e
discusso. Qualcuno ha qualche idea sugli algoritmi da utilizzare e la
strategia di utilizzo di eventuali chiavi ?
Io sono ai primi passi con le NN ma avrei in ogni caso alcune idee, se
qualche "guru" ha intenzione di "addestrarmi" via e-mail ;-) sia il ben
accetto...
----------------------------------------------
Blade Spammer
AntiSpam Net-Runner Unit
" I've seen SPAMs you people wouldn't believe.
   Time to shutdown. "                     ;^)
----------------------------------------------
Real E-Mail : 
jos...@BLADEascu.unian.it
 ... without 'BLADE'
--
Automatic posted from 
gulliver.unian.it
 [193.205.128.24]
via Mailgate Server - 
http://www.mailgate.org


Premetto subito che non sono un guru...
Ho provato a guardare nei miei libri sulle RN ma non ci ho trovato
nulla. Pero' devi considererare che i vantaggi nell'uso delle reti
neurali stanno nel fatto che queste sono in grado di fare inferenze a
partite da set di dati proposti come esempi e con i quali viene fatto
l'addestrameno della rete stessa. A fianco di questi pregi ci sono
pero' anche dei difetti: se addestriamo una rete a fare delle
moltiplicazioni, difficilmente questa rispondera' *esattamente* (e' un
po'  come cercare di fare a mente 136 x 242: magari mi sai dire che fa
un numero vicino a 30000 ma non sai dare una risposta esatta). Se
invece cripto un msg  per poi decodificarlo *devo* avere la massima
precisione.
Detto questo, molto dipende da quello che vuoi fare: non credo che sia
un problema far 'apprendere' ad una RN un algoritmo molto semplice
(come il ROT13), ma, secondo me, usando algoritmi un po' piu' seri
(come il DES e l'IDEA) le cose si complicano: questi algoritmi prima
permutano il blocco di dati e poi applicano sequenze di XOR rendendo
l'insieme di bit pseudo-casuale. Questo significa che, usando
algoritmi ''seri'',  la RN difficilmente puo' generalizzare dagli
esempi proposti una regola generale. Ed esagerando con i cicli di
apprendimento si corre il rischio di un over-fitting.
Cmq prova a dire quali sono le idee di cui parlavi ( e soprattutto se
ho capito quello che volevi fare con una RN) e quali sono le info che
sei riuscito a reperire.
Ciao, Matteo.

 Ciao, Matteo.
----------------------------------------------
Blade Spammer
AntiSpam Net-Runner Unit
" I've seen SPAMs you people wouldn't believe.
   Time to shutdown. "                     ;^)
----------------------------------------------
Real E-Mail : 
jos...@BLADEascu.unian.it
 ... without 'BLADE'
--
Automatic posted from 
ascu.unian.it
 [193.205.128.30]















risultati conseguiti i giorni successivi...


Il sistema che hai trovato per usare le RN come sistema di criptaggio e' 
molto astuto. Pero' mi sembra che ci sia un punto debole: credo che se tu 
provassi a mettere come input delle chiavi abbastanza simili a quelle vere
otterresti lo stesso output. Mi spiego meglio con un esempio che ho provato
a fare (l'ho fatto molto velocemente percio' magari ha fatto qualche errore...)
ho costruito una RN con 16 nodi di input, 20 nascosti e 16 di output. Dunque
ho usato in input due chiavi da 8 byte (in particolare erano le parole 'topolino' e
'paperino') e in output il msg in chiaro ('leopardo') e la nuova chiave ('paperone').
Ho usato la Backpropagation per la minimizzazione dell'errore, la sigmoide come
funzione di attivazione e 300 cicli di apprendimento.
La rete converge molto velocemente, ma se io metto come input due chiavi un po' 
diverse (ho messo 'rotolino' e 'motorino') la risposta e' sempre 'leopardo' e 'paperone'.
Credo che se provassi con parole ancor meno simili, il risultato sarebbe analogo 
(magari provo e poi ti dico).
Forse il problema si puo' risolvere (almeno in parte) generando dei vettori casuali 
per disturbare un po' la rete, ma questo rallenterebbe ulteriormente l'apprendimento.
Tra l'altro non mi e' chiaro perche' la tua rete faccia cosi' fatica a convergere:
forse non ho capito bene il sistema che usi?
Cambiando discorso, dicevi che non si puo' invertire una RN (cioe' passare dall'output
all'input, conoscendo i valori dei pesi): un paio di settimane fa mi e' capitato di dare
un'occhiata all'abstract di un report di alcuni giapponesi che dicevano che usando la 
programmazione matematica non lineare (da quello che ho capito devrebbe essere
una specie di metodo del simplesso un po' modificato) ci riescono. La cosa non e'
che mi sia molto chiara comunque ti riporto l'abstract e l'indirizzo a cui prelevare il
tutto. 
Ciao, Matteo.
ftp.bmc.riken.go.jp/pub/publish/Lu/lu-ieee-tnn-inversion.ps.gz
ABSTRACT:
The problem of inverting trained feedforward neural networks is to 
find the inputs which yield a given output. In general, this problem 
is an ill-posed problem because the mapping from the output space to 
the input space is an one-to-many mapping. In this paper, we present 
a method for dealing with this inverse problem by using mathematical 
programming techniques. The principal idea behind the method is to 
formulate the inverse problem as a nonlinear programming problem. 
An important advantage of the method is that multilayer perceptrons 
(MLPs) and radial basis function (RBF) neural networks can be inverted 
by solving the corresponding separable programming problems, which 
can be solved by a modified simplex method, a well-developed and 
efficient method for solving linear programming problems. As a result, 
large-scale MLPs and RBF networks can be inverted efficiently.  
We present several examples to demonstrate the proposed inversion 
algorithms and the applications of the network inversions to examining 
and improving the generalization performance of trained networks. 
The results show the effectiveness of the proposed method.