Newsgroup: it.comp.ia
Titolo: Spiegazione sommaria del funzionamento di SAM

Ciao a tutti!
Ritengo sia arrivato il momento di spiegare un po' come funziona SAM...
Anche perchè presto sarà disponibile il codice sorgente in VB5/6!
Ricordate di visitare il nostro sito!!! Troverete tutte le informazioni che
cercate (forse ne trovate piu' in questo post :))
http://utenti.lycos.it/aifactory2/Home.html
N.B: prendo le singole parti della descrizione che ho messo nell' Home Page
del progetto e le approfondisco.
----------------------------------------------------------------------------
Quando scriviamo a SAM un'affermazione, il programma scompone la frase (in
input) con un parsing
ed estrae la logica dal discorso.
----------------------------------------------------------------------------
' Passo l'input all'analisi lessicale
Frase1 = Sintassi(Testo, Esito)
--> Viene mandata alla funzione di analisi lessicale e sintattica la frase
--> in input.
--> Questa funzione restituisce la frase corretta di accenti, separate le
--> parole dagli apostrofi; vengono invertiti
--> alcuni pronomi possessivi, viene restituito nella var. esito: l'eisto
--> della frase (".","?","!") e vengono convertiti
--> i  numeri da formato numerico a letterale.
' Faccio l'analisi grammaticale della frase controllata
BlocchiGr = ListGram(Frase1)
--> Questa funzione compie l'analisi grammaticale della frase restituendo le
singole categorie grammaticali
' Prendo i blocchi grammaticali
BlocchiRel = Suddivido(Frase1, Frase2, BlocchiGr)
--> Funzione che, date le categorie grammaticali, le unisce secondo
--> le varie dipendenze.
--> Ad esempio se BlocchiGR fosse: "ad-ss-v-ad-agg".
--> BlocchiRel risulterebbe: "ad ss-v-ad agg"
--> Dove, "ad" è articolo determinativo, "ss" è sostantivo,
--> "v" è verbo e "agg" è aggettivo
' Estraggo la parte logica dal discorso
BlocchiLg = RelazLog(Frase1, Frase2, Esito, BlocchiGr, BlocchiRel, xSogg,
xDati, xSpec, xVerbo, xVInf, xTempo)
--> Questa funzione è una delle piu' complesse da realizzare.
--> Deve riuscire a fare l'analisi logica della frase estraendo il SOGGETTO,
--> LA SPECIFICA DEL SOGGETTO,
--> IL VERBO, IL TEMPO VERBALE e I DATI (intesi come l'insieme dei vari
--> complementi)
--------------------------------------------------------------------
I dati vengono poi trasformati in un formato speciale creato ad hoc e
incorporati nel suo KB (Knowledge Base).
----------------------------------------------------------------------
If Esito = "." And Negaz = False Then ' è un'affermazione
        xSogg = El_Art(xSogg)   ' Rimuovo l'articolo dal soggeto
        xDati = El_Art(xDati)      ' Rimuovo gli articoli dai dati
        Call agg_Relaz(xSogg, xSpec, xVInf, xDati, xTempo, 1)
--> Passo alla funzione che apprende i dati ricavati dall'analisi
--> logica (RelazLog)
--> Questa funzione (agg_Relaz), verifica se la conoscenza
--> passatogli come parametro e già presente in memoria e
--> quindi la aggiunge a quella già presente oppure se è da modificare,
--> e in questo caso la sovrascrive.
--> Invece, nel caso la relazione ricavata dalla frase fosse nuova
--> crea un nuovo concetto.
--> Ad esempio:
-->                     Se io scrivessi: "Mio cugino avrà una bella moto"
-->                     Il formato risultante sarebbe:
-->                     "cugino~(avere_19)bella moto[tuo]" N.B: il numero
-->                     vicino al verbo indica il tempo.
-->                     Se io scrivessi: "Il cugino di giovanni ha 19 anni"
-->                     Il formato risultante sarebbe:
-->                     "cugino~(avere_19)bella
moto[tuo]~(avere_1)diciannove anni[di giovanni]"
-->                     Se io scrivessi: "Un cugino è un parente"
-->                     Il formato risultante sarebbe:
-->                     "cugino~(avere_19)bella
moto[tuo]~(avere_1)diciannove anni[di
-->                     giovanni]~(essere_1)parente[?]"
-->                     Poi, se io scrivessi: "Il cane è un animale"
-->                     Il formato risultante sarebbe: "cane~(essere_1)un
-->                     animale[?]"
-->                     Poi, se io scrivessi: "un animale è un mammifero"
-->                     Il formato risultante sarebbe: "animale~(essere_1)un
-->                     mammifero[?]"
--> Tutta la base di conoscenza risulterebbe:
-->                    "cugino~(avere_19)bella moto[tuo]~(avere_1)diciannove
-->                     anni[di giovanni]~(essere_1)parente[?]"
-->                    "cane~(essere_1)un animale[?]"
-->                    "animale~(essere_1)un mammifero[?]"
--> Sam è formato da piu' programmi exe.
--> Esiste ad esempio quello che genera le inferenze logiche che vengono
--> incorporate in un'altra base dati con pero' lo stesso formato.
--> Ad esempio, partendo dalla conoscenza appresa con le frasi scritte in
--> precedenza, l'altra base risulterebbe:
-->            "cane~(essere_1)un mammifero[?]"
----------------------------------------------------------------------------
Successivamente, quando gli poniamo una domanda, esegue un ragionamento
logico,
attraverso delle micro-istruzioni di ricerca, per individuare i dati utili
al fine
di ricavare la risposta.
----------------------------------------------------------------------------
In SAM non sarà presente in nessuna parte del codice un algoritmo che gli
dice come e cosa rispondere.
Quando riceve una domanda in input dovrà riuscire automaticamente a capire
cosa voglio sapere.
A questo punto invierà alla procedura comunemente chiamata GPS (General
Problem Solver), come stato
iniziale del problema, la condizione che lui non conosce cosa voglio sapere,
mentre come stato finale, quello che voglio sapere.
Poi tenta di ridurre la differenza tra i due stati (quello iniz. e quello
finale) tramite operatori (presenti nella base
di conoscenza); in questo caso essi non sono altro che i nomi delle funzioni
di ricerca dati che abbiamo creato in VB
(nel modulo della gestione della conoscenza). SAM li combina, secondo una
sua logica, adattandoli ai dati ricavati dalla domanda formando
un vero e proprio algorimo in VBScript, che, venendo eseguito vengono
ricavati (solo sottoforma di dati in formato speciale)
----------------------------------------------------------------------------
Trovati i dati, SAM, compone una frase rispettando le regole grammaticali
della lingua italiana.
----------------------------------------------------------------------------
Non saprei cosa aggiungere :))
-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.
Spero di essere stato abbastanza chiaro e vi ricordo che sam è diventato un
progetto Open-Source!
Ciao,
Matteo

 
Spiego un po' come funzionava il mio cAIno (a memoria xche' ho perso i 
sorgenti, tanto era pessimo codice..) magari ne esce qualche cosa di 
utile (ne dubito)
Lasciando perdere il mio fallimentare tentativo di analisi 
logico/grammaticale arrivavo ad avere una frase composta cosi':
Tipo della frase (principale,subordinata,temporale)
Soggetto + eventuali attributi
Verbo
Oggetto + event. attr. 
Condizioni(frase)
Affermativa/negativa
Utente
Utente serve perche' cosi' si possono distinguere le diverse opinioni e 
le verita' relative ad ogni utente (c'era l'utente speciale "Dio" per 
insegnare le verita' universali)
Ogni nome di cosa concreta aveva come proprieta' (ognuna con eventuale 
negazione):
.cosaEssere(cane essere mammifero -> eredita le proprieta' di mammifero)
.cosaPuoEssere (cane puo' essere nero -> ma non tutti i cani lo sono)
.cosaFare + condizioni 
.cosaPuoFare + condizioni
Una cosa importante che volevo fare, ma non avevo ancora stabilito come, 
e' distinguere i soggetti "generali" a quelli specifici nel tuo esempio:
[Mio cugino avrà una bella moto] creera' un nuovo concetto "cugino di 
utenteX" che avra' come campo .cosaEssere=cugino e quindi ereditera' le 
proprieta' generali che hanno tutti i cugini.

 proprieta' generali che hanno tutti i cugini.
Senti...
Dato che, come vedi le idee che abbiamo per creare un bot sono quasi sono le
stesse,
che ne dici di UNIRTI al MIO team A.I-FACTORY2 !!??
Anche se non sai VB non preoccuparti perchè:
    1) E' talmente semplice che non hai difficoltà a capire il codice: no
utilizziamo comandi *strani* :))
    2) Ci pensiamo io e Hidez a trasformare lo pseudo-codice (che creiamo
insieme a te) in codice VB!!!
Spero la tua risposta sia affermativa,
Matteo

 Va bene.. ti mando una mail se vuoi dirmi qlcosa in pvt
Ok. Manda pure :)

, 
nie...@posta.it
 
says...

Mi sono mangiato un pezzo: Per fare si' che il bot "capisca" il 
significato dei verbi ad ognuno di essi corrisponde un'insieme di 
conseguenze (con eventuali condizioni).. facendo un esempio macabro:
Per il verbo Uccidere ci sara':
OGGETTO essere morto
SOGGETTO essere assassino
cosi' scrivendo "Gino uccide Pino" il bot coclude
"Pino essere morto (perche' Gino uccide Pino) " e 
"Gino essere assassino (perche' Gino uccidere Pino)"
Cosi' si creano un sacco di connesioni tra oggetti diversi..

 per le regole di produzione.
Perche' non provi ad usarne uno gia' fatto, stile CLIPS ?
S.


Perchè mi risulterebbe difficile adattarlo alla mia struttura
dati! E forse non funzionerebbe come vorrei... :)

 dati! E forse non funzionerebbe come vorrei... :)
Non e' mica detto... In effetti il VB lo vedo male, pero' ad esempio
utilizzando JESS puoi montare attorno al motore inferenziale di CLIPS
qualsiasi tipo di struttura dati (in Java).
Stefano

 ha scritto nel messaggio
news:oY3F9.28186$3l.7...@twister1.libero.it...
