Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Ricerca degli stati: si hanno una serie di stati che devono essere visitati per ottenere una soluzione
Agenti Intelligenti: si vuole raggiungere un risultato con il minor costo possibile, quindi costruire un
agente, entità software che riceve degli stimoli (percept) e fornisce in output delle azioni (action).
f:P*->A
P*: sono tutte le azioni formate da A e P
A: è l’insieme delle possibili azioni
I percept possono arrivare da un enviroment e/o compiti specifici (task). Lo scopo di un agente è quello di
ottenere le migliori performance (un buon risultato di razionalità). Tuttavia a volte è impossibile
raggiungere la razionalità perfetta a causa delle performance.
AGENTI RAZIONALI
Si vuole definire una misura di performance. Le prestazioni dipendono da cosa si vuole ottimizzare.
Nell’esempio dell’aspirapolvere si può tenere conto della quantità di polvere aspirata (massimizzare il
parametro) o il tempo impiegato (da minimizzare). Tuttavia i due parametri sono in contrasto, uno da
massimizzare e uno da minimizzare. Si cerca quindi di avere un tradeoff tra i due (bilanciamento). Altri
parametri potrebbero essere il consumo e il rumore. A volte bisogna controbilanciare il tutto.
Le misure di performance vengono usate per dire cos’è e cosa fa un agente attraverso la definizione del
PEAS (Performance Measure Enviroment Sensor). Esempio PEAS taxy:
TIPO DI AMBIENTE
Completamente osservabile: l’agente Parzialmente osservabile: non conosce
conosce tutto l’ambiente tutto l’ambienta ma solo alcune
informazioni
Deterministico: eseguo un’azione e Stocastico: non si ha sempre il 100% di
sono sicuro di quell’azione sicurezza nell’eseguire un’azione
Episodico: l’esecuzione dell’azione Sequenziale: una sequenza di azioni, in
viene fatto una sola volta questo caso le azioni hanno una “storia”
tra di loro.
Statico: l’ambiente non cambia mai Dinamico: Cambia sempre
Discreto: un certo numero di Continuo: n oggetti indefiniti e in
azioni/percept distinte continuo cambiamento
Singolo agente Più agenti
In un ambiente deterministico (le azioni hanno risultato certo), completamente osservabile, l’agente riceve in
input uno stato(stato iniziale) e ne restituisce un altro stato (l’agente conosce obbiettivo e azioni, quindi si
tratterà di confrontare lo stato iniziale con quello finale e eseguire le azioni che lo porteranno allo stato
finale).
es. azione deterministica : a:S->S a(S1) = S3
es. azione non deterministica : a:S->2s (in input uno stato iniziale, in output un insieme di stati possibilii)
x={x1,x2} 2x={0,{x1},{x2},{x1,x2}}
a(S1) = {S2,S3} significa che è un ambiente non deterministico.
Azioni condizionate:
[right, if dirty then suck], in questo caso si eliminano alcune
azioni inutili, grazie alla condizione if, questa permette di controllare lo stato della stanza ( cosi si hanno
informazioni aggiuntive).
Soluzione: sequenza di azioni per cui posso andare da uno stato iniziale allo stato di goal. Tra tutte le
soluzioni ci interessa quella con costo minimo (Soluzione ottimale)
Potrei applicare un qualsiasi algoritmom di cammino minimo, ma lo spazio degli stati potrebbe essere infinit
, per cui devo applicare delle strategie di ricerca, che mi permetto di costruire una parte dello spazio degli
cioè quello che mi consente di arrivare la soluzione.
STRATEGIA DI RICERCA
Lo spazio degli stati può essere enorme o infinito (non posso rappresentare il grafo). Una soluzione
alternativa è quella di costruire solo la parte dello spazio degli stati che serve. Per ogni azione applicata, si
generano stati da aggiungere al grafo.
Ogni nodo (che rappresenta una stato) ha:
◦ un nodo genitore (stato che lo genera)
◦ più figli (applicando delle azioni si generano i figli)
◦ Informazioni aggiuntive quali:
▪ funzione di costo g(x)
▪ profondità d
Expand(): partendo dallo stato corrente, si generano tutti i nodi successivi (stati possibili), applicando delle
azioni.
La scelta del prossimo nodo a cui applicare expand() identifica la strategia di ricerca. Ogni strategia è
caratterizza da 4 parametri di efficienza:
1. Completezza: completa quando se esiste una soluzione, la ricerca la trova.
2. Complessità in tempo: n° di passi per arrivare alla soluzione
3. Complessità in spazio: n° di nodi memorizzati al massimo
4. Ottimalità: trova la soluzione con il minor costo
Per misurare questi parametri useremo:
b: (Breanching Factor) fattore di diramazione massimo (massimo dei figli generabili da un nodo)
d: profondità della soluzione ottimale
m: massima profondità raggiunta dalla strategia
ALGORITMO
while(s != goal){
frontier= frontier U expand(S) //si espande e si aggiunge alla
frontiera
s -<- select(frontier)
}
OutPut(path n0->s)
Strategie non informate: basate sul livello del nodo, utilizzate solo come confronto.
BFS
In una ricerca BFS i nodi di espandono usando l’ampiezza dell’albero che viene generato. Si usa FIFO.
Catatteristiche:
1. Completezza: Sì se il fattore di diramazione b è finito, esamina tutti i livelli e al livello k trova il
nodo, se esiste una soluzione
2. Tempo: 1 + b + b2 ... bd + b(bd-1) = O(bd+1) 1 al livello 0, b al livello 1, b2 al livello due e cosi via, bd
è la profondità della soluzione, mentre b(bd-1) sono i fratelli del nodo della soluzione.
3. Spazio: Si devono tenere in memoria i nodi che rappresentano la frontiera (esponenziale per livello)
O(bd+1)
4. Ottimalità: Se tutto costa 1 si, ma non è ottimale. Trova prima le soluzioni a livello più alto
DFS
In una ricerca DFS si espandono prima i nodi con profondità più elevata, si usa stack LIFO. Catatteristiche:
1. Completezza: Se lo spazio degli stati è finito sì, altrimenti in loop per spazio infinito
2. Tempo: O(bm) m è la profondità massima, per risalire deve arrivare in fondo
3. Spazio: O(b*m) il n° di nodi è lineare rispetto alla profondità
4. Ottimale: No, può esistere una soluzione a livello più alto in un ramo non esplorato.
É una variante della DFS che combina l’ottimalità di BFS. L’IDS ripete una DFS fino al limite fissato detto
cutoff. Arrivato al cutoff, si ripete la visita aumentando il cutoff di 1 (backtracking). Ha la caratteristica
liberare lo spazio dai nodi superiori allo stato corrente, così da mantenere in memoria solo la frontiera.
Troverà quindi la soluzione al livello corretto d.
Caratteristiche:
1. Completezza: se esiste una soluzione al livello k, trova la soluzione quando cutoff = k
2. Tempo: (d+1)b0 + db1 +(d-1)b2 + ... + bd = O(bd). Come la BFS, ma evito di espandere l’ultimo
livello, che avrebbe dominato sulla complessità.
3. Spazio: O(b*d), mantiene le prestazioni della DFS, anche se più grande in tempo.
4. Ottimale: con il cutoff al livello d, esamino tutto d e trovo la soluzione.
Si associa ad ogni nodo una valutazione di costo f: S ->R+ (f identifica il tipo di ricerca), cercando di
minimizzare il costo finale (ad ogni espansione è scelto il nodo con costo minimo, utilizzo di heap o coda di
priorità). Si sceglie quindi il nodo migliore: Best-First Search.
UNIFORM COST
La funzione di costo indica il costo delle azioni per andare da S(sorgente) al nodo corrente.
{ 0 se n = n0 // il nodo inizial
g(n){
{ g(n’) + c(n’,n) // con n’ padre di n e c è il costo
La best first search utilizza questa strategia: algoritmo “a costo uniforme” perché tende a selezionare i nodi
in ampiezza (può degenerare in una BFS). Più scendiamo più il costo aumenta (funzione additiva). Quando
questo algoritmo arriva al nodo obiettivo, non si ferma, ma controlla tutti gli altri, potrebbe trovare un
percorso migliore. Si ferma solo quando si seleziona il nodo migliore.
Caratteristiche:
1. Completezza: è completo se il costo è positivo
2. Tempo: l’algoritmo tende ad andare in ampiezza, nel caso peggiore è uguale ad una ricerca in
ampiezza. Tuttavia è O(b[c*/epsilon]) nel caso medio (C* è il costo della soluzione ottimale).
3. Spazio: uguale al tempo, quindi vi è un problema di spazio esponenziale
4. Ottimalità: Sì, si ferma solo quando la soluzione è la migliore.
FUNZIONE EURISTICA
La funzione di valutazione prova a capire quanto ancora devo spendere per arrivare alla soluzione.
h(n) = c(n, ng) // stima del costo per andare da n a ng
Principio per le stime: la stima dev’essere una sottostima. Questo perché è possibile ottenerne una
attraverso il rilassamento del problema. Esso prevede di eliminare dal problema alcuni vincoli, rendendo il
problema più semplice fino a poterne calcolare facilmente la soluzione. La soluzione ad un problema minore
è appunto una sottostima. Si tende a scegliere la sottostima
calcolata sul problema rilassato al minimo, per ottenerne una più
vero-simile.
es. 8-puzzle
GREEDY SEARCH
Si tratta di una Best-first Search in cui la funzione di valutazione è solamente la funzione euristica. Ad ogni
iterazione si prende in considerazione il nodo che si pensa possa essere più vicino all’obiettivo. Più ci si
avvicina all’obiettivo, più i valori della funzione euristica diminuiscono (contrario della funzione di costo).
Caratteristiche:
1. Completezza: No, potrebbe entrare in loop
2. Tempo: può degenerare in O(bm)
3. Spazio: può degenerare in O(bm)
4. Ottimalità: No, può restituire un’altra strada
STRATEGIA A*
Permette di guidare la ricerca sfruttando le informazioni di costo e quelle euristiche, funzione di valutazione:
f(n) = g(n) + h(n)
Caratteristiche:
Non dà nessuna garanzia di degenerazione, nel caso
peggiore è come la BFS (visita tutti). Può essere
peggiore in spazio e tempo (si deve milgiorare
l’euristica, evitando di occupare tanta memoria).
1. Completezza: Sì, prima di andare oltre la frontiera espando tutti i nodi, quindi troverò la soluzione
2. Tempo: può degenerare in O(bd)
3. Spazio: può degenerare in O(bd)
4. Ottimalità: se l’euristica è ammissibile allora A* è ottimale (Teorema successivo)
Proprietà di consistenza
Afferma che se un’euristica è consistente, allora è anche ammissibile (non è detto il contrario) e quindi A*
ottimale. Si basa sulla disuguaglianza triangolare per la quale:
h(n) <= h(n’) + c(n,a,n’)
Con G obiettivo, h(n’) = stima n’-G, h(n) = stima n-G.
Quindi se è consistente, la f(n) non decresce mai, con la h(n) sempre più
precisa e la g(n) in aumento, migliorando l’algoritmo ad ogni passo.
EQUAZIONE DI PATHMAX
Se si ha un’euristica non consistente, e non migliora la precisione, cioè se è ammissibile ma non
consistente, si può usare l’equazione di pathmax.
In questo esempio si nota come da n a n’ la f decresca.
Si tratta di una ricerca in profondità iterata con cutoff sul valore di f di A*. Se non si riesce ad andare avanti,
il cutoff viene reimpostato con la più piccola f incontrata e si riparte da capo. Se l’euristica non è buona A*
tiene troppi nodi in memoria, mentre IDA tiene solo i nodi utili, migliorando la complessità in spazio.
__________________________________________________________
(Dopo n° mosse)
GRAPH SEARCH
Se l’euristica è consistente si può applicare una graph search, quando un nodo viene inserito nella lista di
quelli chiusi, non verrà rigestito.
Scelta stocastica: Si possono generare dei numeri pseudo casuali tra 0 e 1 in maniera uniforme.
Dove P1+P2 = 1
Ogni nodo possiede il valore di utilità, quindi, la probabilità deve essere in funzione dell’utilità. Si fa una
normalizzazione a 1. Si prende un numero e lo divido per la somma degli altri. Se S0 ha 5, S1 10 e S2 20. S2
deve avere il doppio delle probabilità. Calcolo probabilità di S1: 10/(10+20) = 1/2.
SIMULATED ANNEALING
Variante dell’HC: invece di andare sempre verso stati migliori, ogni tanto si va verso una “mossa cattiva”
cosi da esplorare più strade alternative. La mossa cattiva deve essere fatta con un certo criterio: tanto più la
mossa è cattiva minore dev’essere la probabilità di farla. L’algoritmo ha una fase iniziale ed una di regime.
Nella fase inziale dev’essere molto probabile eseguire una mossa cattiva: la riuscita dell’algoritmo dipende
molto dallo stato di partenza, cosi facendo cerco di ottenere un buono stato di partenza.
Problema: la temperatura! Con T molto basso tende a diventare un HC, mentre se è troppo alta esplora
troppo. Bisogna bilanciare il parametro T. Solitamente si usa un T logaritmico (esponenziale troppo veloce,
lineare troppo lento) se T decresce piano l’algoritmo è ottimale.
Variante: Stochastic beam search. Ad ogni passo tengo k stati selezionati casualmente con una probabilità
proporzionale alla loro funzione di valutazione.
ALGORITMI GENETICI
Si vogliono ottimizzare gli stati nel tempo, simulando l’evoluzione (riproducendo e selezionando gli
individui migliori). Gli stati successori sono generati da coppie di stati.
Gli stati sono rappresentati come stringhe di bit (o simboli) chiamati geni, i cui valori sono detti alleli e
mutuano casualmente. Uno stato è detto individuo(insieme di stati), un insieme di individui è una
popolazione.
Ogni individuo ha associata una funzione di utilità(funzione di fitness), quindi si dovrà selezionare
l’individuo con la funzione di fitness maggiore. la popolazione finale avrà questo valore massimo.
Si eseguono tali operazioni affinchè il numero della popolazione non sia ripristinato. Ad ogni generazione di
figli la fitness function aumenta, migliorando di generazione in generazione.
Deterministico A chance
Info perfetta Scacchi, go, othello Backgammon
Info imperfetta Bridge, poker
Tutti i giochi analizzati sono a somma 0, cioè quello che vince uno perde l’avversario (payoff).
Terminologia:
1. Utilità: ad ogni configurazione finale verrà associata un utilità(con il vincolo della somma 0, quindi se
un giocatore avrà un utilità u, il giocatore 2 avrà un utilità -u).
2. Strategia: sequenza di azioni condizionate dalle contromosse dell’avversario.
a) pura – scelta deterministica
b) mista – distribuzione di probabilità su scelte deterministiche pure
Consideriamo un gioco G con due concorrenti: max (che vuole massimizzare il payoff, agente), min
(minimizza il payoff, avversario). Max usa la strategia ‘s’ e min ‘t’, l’utilità che ne viene fuori è :
U(s,t) → di max
-U(s,t) → di min
TEOREMA DI MINMAX
Supponiamo di avere un gioco finito G a somma 0 con due giocatori. Quindi abbiamo due strategie: s*
(max) e t* (min). Inoltre abbiamo un numero Vg chiamato “valore di minmax di G”.
1. Se min usa t* allora l’utilità attesa da Max sarà <= Vg cioè Vg → maxU(s,t*)(cioè il massimo delle
strategie s mi porta a Vg, qualsiasi altra strategia mi porta a un valore inferiore) → ottimale per min
2. Se max usa s* l’utilità attesa da Max sarà sempre >=Vg min non potrà mai scendere sotto Vg →
minU(s*,t) → ottimale per max
i due punti precedenti fanno in modo che ci sia una convergenza. Il teorema garantisce inoltre che se il
gioco è a informazione perfetta allora queste due strategie pure esistono.
Supponendo che l’ avversario usi la strategia ottimale(s* o t*), l’algoritmo deve trovare la strategia ottimale
che fa convergere l’utilità a Vg.
In questi casi conviene utilizzare delle rappresentazioni ad albero, cosi da poter alternare i livelli dell’albero
con le mosse dei giocatori(avendo 2 giocati, prima gioca Max o Min ecc...).
branching factor – b : diminuisce ad ogni passo (si intende il numero di mosse che posso fare da una
determinata configurazione)(si usa quello medio, solitamente di max)
altezza albero – h(massima profondità raggiungibile da una determinata configurazione)
Complessità strategia in tempo e spazio = O(bh) → numero di azioni e numero di configurazione che devo
gestire.
ALGORITMO DI MINMAX
Obiettivo: trovare il massimo quando l’altro cerca di trovare il minimo. Supponiamo di generare l’albero con
i valori di utilità (nei nodi terminali). Partendo dalle foglie(gli unici con dei valori di utilità), si guarda il
nodo padre:
1. se è min → viene sintetizzato il minore dei suoi figli
2. se è max → viene sintetizzato il massimo dei suoi figli
Caratteristiche:
Correttezza: si (non dimostrato),
ottengo minmax
Completezza: si se si hanno alberi
finiti.
Complessità:
Tempo – O(bh).
Spazio – Si può limitare
generando l’albero seguendo un
solo cammino alla volta(DFS)
- O (b*h).
Problema: per gli scacchi, supponendo b = 35 e h = 100, l’albero avrebbe circa 10135 nodi!
È possibile applicarlo lo stesso, ma solo dopo aver eseguito un po’ di mosse ed aver eliminato alcune
strategie. Negli stati iniziale non si può decidere quale strada intraprendere dato che non si riesce ad arrivare
alla fine (troppi nodi). Non si riesce ad avere un valore di utilità. Quindi si cerca di fare una stima generando
l’albero fin dove si può, ma perdendo precisione. Più in basso riesco ad andare più precisa sarà la stima.
FUNZIONE DI VALUTAZIONE
Cambia da gioco a gioco, può essere una combinazione lineare (somma dei fattori) dei possibili attributi
Es. x1, x2 .., xk con un peso w1, w2 .., wk, allora si avrà -> x1*w1 + x2*w2 + .. + xk*wk
Si identificano una serie di caratteristiche e gli si assegna un peso, così si ha un idea di quanto può valere
uno stato rispetto ad un altro. Più alto è il valore più sarà favorevole per max, inversamente per min.
Pesi:
Regina → 9
Pedone → 1
ALFA-BETA PRUNING
L’obiettivo è incrementare il cutoff. L’algoritmo elimina i rami inutili il più possibile. Si riesce così ad
aumentare il look-ahead utilizzando le risorse risparmiate. Tuttavia il numero di tagli dipende dall’ordine in
cui visito i nodi. Si tagliano i nodi più grandi del valore minimo (per min) e più piccoli per max.
Proprietà:
La potatura non ha effetti sul risultato finale
Con l’ordine perfetto, la complessità in tempo diventa e O(bm/2)
Raddoppia la profondità di ricerca
Logica non monotona: concludo qualcosa temporamente, cosi in caso di negazione posso rimuoverla.
Due sistemi che risolvono questa problematica sono: CBR (imparano da esperienze passate, senza ricavare
una regola, poiché è spesso difficile da realizzare) e i modelli grafico probabilistici (modelli per la
conoscenza incerta).
Si cerca di recuperare un vecchio caso simile per adattare la vecchia soluzione al nuovo problema.
Revise: partendo dalla soluzione recuperata (e non direttamente applicabile al caso corrente), la si
modifica adattandola al caso corrente, utilizzando la conoscenza sul dominio.
Retain: si decide se memorizzare o meno il caso corrente con la relativa soluzione (learning).
Normalmente va fatto quando:
1. la soluzione è stata prodotta con una fase di revise molto pesante
2. La soluzione è stata fornita dall’esterno perchè nemmeno Revise è riuscita a garantirla
I dati in memoria si recuperano utilizzando il Case Indexing, che fornisce al sistema conoscenza anche su
come eseguire il match (si prendono in considerazione solo gli attributi discriminanti). Serve una memoria
per organizzare i vari casi:
Memorie Piatte
Memorie Strutturate
Decision Tree
K-D tree – utile per recuperare tante info da tanti attributi
Database relazionali/oggetti (utilizzato attualmente, tuttavia non si possono usare le normali query sql,
essendo troppo rigide, non possono gestire le similarità)
Ibrido tra DB e Decision tree
Per ognuno avremo diversi algoritmi di ricerca e diverse modalità di gestione della memoria.
MEMORIE PIATTE (associative)
DECISION TREE
Si tratta di un albero dove i nodi sono attributi e gli archi uscenti arrivano ad altri attributi e sono etichettati
con condizioni sui valori dell’attributo. Il nodo radice può essere ripetuto. Potrebbe esserci come caso finale
un insieme di stati con soluzioni diverse. Sono utilizzati per problemi di classificazione delle query, cioè
hanno associate delle classi che contengono delle soluzioni:
Dataset (training set): <attributi descrittivi, classe>, nel machine learning si fanno vedere degli esempi
con la soluzione, sono l’insieme di allenamento, servono per fare apprendere il modello all’ia.
Query<attributi descrittivi> solamente alcuni attributi, ma sicuramente non la classe poiché è la
soluzione
Soluzione, determinare la classe della soluzione.
Le foglie indicizzano un insieme di casi (istanze) e tengono traccia di quanti casi ci sono nelle varie classi
(soluzioni). Ci sono vari algoritmi, in particolare C4.5 genera in output automaticamente un decision tree.
SIMILARITÀ: Nei decision tree si recuperano casi simili con una nozione implicita di similarità, data dalla
comunanza di valori rispetto ad una classe (distanza). Non sempre gli attributi sono generici, ci vuole una
nozione esplicita di similarità.
Il matching indica “quanto” due casi sono simili, per fare ciò si ricorre alla metrica (o distanza) tra punti
(X è molto simile a Y sse X è poco distante da Y). Un caso viene rappresentato con punti n-dimensionali,
dove ‘n’ è il numero di attributi del caso. Se ne calcolo la distanza con un altro caso, allora:
similarità = 1 - distanza
KNN esegue una scansione lineare ottenendo i k casi simili, solitamente si usa k=1
NB: Se x e y hanno lo stesso peso incrementa come una circonferenza.
Tipologia di attributi:
Nominali (o categorici): i valori non posseggono un ordinamento (es. colori), quindi non si possono
fare differenze.
Lineari: i valori posseggono un ordinamento
Discreti: mappabili su numeri naturali (es. Età (0,1,2,...), temperatura (bassa < media < alta))
Continui: mappabili su numeri reali (es. Temperatura espressa in gradi)
METRICA ETEROGENEA
(Hetereogeneous Euclidian Distance Metric - HEOM)
f = attributo
df = distanza su f
x,y sono i valori che può assumere.
Se inserisco una metrica su un singolo attributo, come faccio ad applicarla su un caso che è composto da k
attributi? Devo applicare la similarità tra ogni attributo e poi combinarle insieme.
La combinazione delle distanze (aggregazione o distanza globale) è una media ponderata. Si sommano
tutte le distanze per il loro peso e si divide per la somma dei pesi. La similarità è data da S= 1-D(Ci,Cj)
Esempio calcolo
similarità
HETEROGENEOUS VALUE DISTANCE METRICE (HVDM)
IMPLEMENTAZIONE K-NN
Si esegue una scansione lineare, si calcolano le distanze con il caso target e si restituiscono i k risultati più
“vicini” (costo O(n))
Si utilizzano kd-trees (costo O(log n) per k=1), per recuperari i casi “vicini”. Sono alberi di ricerca dove un
nodo rappresenta un punto n-dimensionale(quindi un caso), su ognuno di essi si esegue uno split binario su
una dimensione(su un attributo). Necessità di costruzione (costo O(n log n)) e mantenimento (costo O(log
n)) della struttura.
IDEA: Si usa una coda di priorità (heap) dove ogni punto (caso) ha associato un valore che è una sottostima
della distanza del punto dalla query. Ad ogni nodo verifico la condizione rispetto alla query, cioè navigo
nell’albero rispetto alla query:
Il nodo figlio sul ramo verificato è aggiunto alla heap con valore 0 (nel caso migliore in quel sotto-ramo
vi sono nodi a distanza 0 da query)
Il nodo figlio sul ramo non verificato è aggiunto alla heap con valore pari alla differenza tra valore di
soglia della condizione e valore nel nodo query (nel caso migliore, da quel lato ci sono nodi ad almeno
quella distanza dalla query nella dimensione corrente)
Ad ogni passo si tengono il miglior nodo trovato (best) e la sua distanza dalla query (best_dist). L’algoritmo
termina (restituendo best e best_dist) se: l’heap si svuota o il migliore della heap è il peggio del best.
ADATTAMENTO (Revise)
Se il passo di Reuse trova una soluzione non applicabile nel nostro caso, bisogna adattare la soluzione
trovata per il caso query. Questa quindi va cambiata in qualche parte o anche solo per qualche parametro:
Transformational adaption: riuso della soluzione recuperata, combinando i parametri o aggiungendo o
modificando le part. Si esegue modificando attributi della soluzione, oppure aggiunte modifiche o
cancellazione di parti della soluzione.
Derivational adaption: si mantiene la traccia della soluzione, di come è stata generata, cosi da poterla
riapplicare al caso corrente. Particolarmente utile nei problemi di Case-Based Planning
Tipicamente vengono fatte delle regole ad-hoc per ogni sistema. In caso di fallimento dell’adattamento della
soluzione, potrebbe esserci un problema di apprendimento.
RETAIN
In questa fase si decide se tenere la nuova soluzione (learning)
oppure cancellare il caso (forgetting). Ci vogliono delle funzioni di
valutazione per decidere cosa fare in questi casi. Utility
problem(swamping problem): limite in cui diventa dannoso
aggiungere i casi, le performance peggiorano. Si vuole valutare la
performance del sistema tramite i seguenti parametri: tempo di
esecuzione, qualità delle soluzioni, competenza del sistema (capacità
di fornire soluzione). Queste caratteristiche dipendono dal numero
dei casi in memoria e dalla loro qualità.
Si tenderebbe a pensare che più casi in memoria corrispondano ad una migliore competenza, migliore
qualità della soluzione e peggior tempo di risposta. Mentre con meno casi: peggior competenza, peggiore
qualità e miglior tempo di risposta. L’utility problem ha lo scopo di massimizzare le performance:
se arriva un problema e si risolve con reause -> non si inserisce
se arriva un problema e si risolve con con l’adattamento -> non si inserisce
se arriva un problema e si risolve con l’adattamento ed esso è pesante -> va inserito
se il problema non è stato risolto, si cerca la soluzione -> si inserisce la soluzione
Il K-NN degenera all’aumentare delle dimensioni (numero di attributi) dello spazio considerato ( con D=1 ci
sono 2 NN, con D=2 ci sono 4 NN, con D=3 ve ne sono 6 e cosi via). Una soluzione al problema è quella di
usare solo gli attributi utili (features selection).
RAGIONAMENTO INCERTO
Ragionare in presenza di conoscenza incerta (mancanza di informazioni) -> Calcolo delle probabilità
Solo il calcolo delle probabilità si è dimostrato generale ed adeguato, in passato vi furono diverse altre
soluzioni. Una delle obbiezzioni che venne fatta era che il calcolo delle probabilità non è un formalismo
umano, nel caso dell’ AI vennè superato:
Descrittivo vs Normativo
Descrittivo: Descrivo quello che vedo e cerco di riprodurlo.
Normativo: si cerca di arrivare alla soluzione, tuttavia non ricostruisco esattamente l’obiettivo.
ELEMENTI DI PROBABILITÀ
ASSIOMI DI KOLIMOGOV
Assioma 1
P(Ω) = 1 -> quello che va oltre omega non è nel nostro modello
Assioma 2
per ogni X appartenente a 2^ Ω(sottoinsieme del sottoinsieme di omega) 0<=P(X)<=1
Assioma 3
PROBABILITÀ TOTALE
Se H1, ...Hn sono eventi mutuamente esclusivi ed esaustivi, allora un dato evento E:
NB. Mutua esclusione è l’opposto di indipendenza (se si verifica un evento NON si verifica l’altro)
RANDOM VARIABLES
In AI, invece di parlare di eventi si preferisce normalmente lavorare su random variables(variabili casuali o
aleatorie). Una r.v. è una variabile che può assumere valori in un dato dominio, su cui è definita una
distribuzione di probabilità (ossia una funzione che indica con che probabilità la variabile assume certi
valori). Se assumono solo un numero finito di valori si dicono variabili discrete. Distribuzione di variabili
aleatorie:
RETI BAYESIANE
Soggettivista: reti Bayesiane. La probabilità è intesa come il grado di certezza assegnato ad un evento
soggettivamente, ma in modo coerente. La probabilità di un evento E è considerata essere la quantità di
utilità P(E) che un individuo è disposto a scabiare ricevendo in cambio: 1 se E avviene, 0 altrimenti.
TEOREMA DI BAYES
Siano h1, ...hn degli eventi mutuamente esclusivi ed esaustivi. Sia e un evento qualsiasi (evidenza). Allora:
Esempio applicazione Bayes
Se ho più evidenze da considerare, è difficile generalizzare il T. Bayes. Però se per ipotesi le evidenze sono
indipendenti tra di loro, diventa:
RAPPRESENTAZIONE GRAFICA RETI BAYESIANE
E quindi:
In generale:
Esempio
INDIPENDENZA CONDIZIONALE
SEMANTICA LOCALE
COPERTA DI MARKOV
TIPOLOGIE DI RAGIONAMENTO
Quando ci si concentra su una variabile, bisogna anche osservarnee i genitori: se questi sono tanti potrebbe
diventare un problema riuscire a rappresentare tutto in una CPT (condition probability table (TCP in
italiano)). Una soluzione a questo problema sono le distribuzioni canoniche. Esse sfruttano qualche
regolarità che permette una rappresentazione compatta. Ne esistono di due tipi:
Nodi deterministici
Noisy OR
NODI DETERMINISTICI
Sono il caso più semplice di rappresentazione canonica: X = f (Parents(X)) per qualche funzione f. Il valore
di un nodo è specificato in modo univoco dai valori dei nodi genitori tramite funzione che calcola il valore.
NOISY-OR
Sia X una variabile booleana con U1 ..Uk genitori booleani (si dovrebbero inserire 2k valori). Sia pi la
probabilità che X sia vera quando Ui è vera e tutti gli altri U sono falsi. Infine sia X falso quando tutti gli Ui
sono falsi. Nel Noisy-OR il nodo figlio è falso solo se tutti i genitori che valgono vero sono inibiti. La
probabilità di questa inibizione è il prodotto delle probabilità di inibizione di ciascun genitore. Quindi la
probabilità che il nodo figlio sia vero è 1- il prodotto delle probabilità di inibizione dei genitori che valgono
vero:
Leak: riassunto delle cause non modellate, probabilità che la variabile abbia uno stato in tutti gli altri casi
non in memoria.
Ovvero: le probabilità sono la somma di tutte le probabilità congiunte con q ed e e tutte le occorrenze delle
altre variabili. (Marginalizzazione: tengo le variabili che mi interessano).
NB. La congiunta la ottengo moltiplicando tutte le probabilità delle variabili negli stati che interessano
(vero/falso o altri stati).
Il problema è rimanere nella rappresentazione implicita, se ritorno alla probabilità congiunta non risolvo
niente, perdo efficienza: non bisogna avere una joint esplicita!
Tipologia di algoritmi:
Esatti: fornisce il valore esatto delle probabilità a posteriori fino a una precisione decisa. Si usa in reti
piccole o con cammino unico tra due nodi. (NB. Diventa NP-Hard nel caso di cammini multipli!)
Approssimati: forniscono una stima, più precisa con più tempo a disposizione (simulazione
stocastica).
ALGORITMI ESATTI
Se le reti sono singly-connected, esiste un algoritmo a scambio di messaggi che trova le probabilità in tempo
polinomiale. Algoritmo di Kim-Pearl: ogni nodo indica ai vicini di essere stati osservati, prende
l’informazione, cambia le probabilità e ritrasmette il messaggio.
Se invece è multiply-connected, l’algoritmo va in loop. L’idea è di trasformare la rete m.c. in s.c., eseguire
l’algoritmo e ritrasformare i risultati sulla rete originaria
Due metodi di trasformazione: clustering e conditioning.
CLUSTERING
Si raggruppano dei nodi per trasformare la rete in singly-connected. Le probabilità del raggruppamento è la
combinazione vero/falso delle probabilità (prodotto cartesiano, posso farlo perché conosco il padre, quindi
Spr e Rain sono indipendenti).
NB. Funziona male con i grafi con tanti genitori, si creano tabelle di probabilità grandi. Una delle regole di
clustering è unire (moralizzare) i nodi che hanno un figlio in comune.
Si stabilisce un ordinamento delle distribuzioni della rete e si calcola la query eliminando (con la
marginalizzazione) le variabili non richieste. Ordinamenti diversi danno luogo ad efficienza diversa.
L’Ordinamento ottimale (minor numero di operazioni da effettuare) e’ problema NP-hard. Si usano quindi
delle euristiche Altro nomi per l’algoritmo: Bucket Elimination, Factoring.
* Il prodotto coinvolge tre variabili: fA B E J M (A,B,E) = fA,B,E (A,B,E) fA,J (A) fA,M (A)
VARIABILI IRRILEVANTI
Quando ho la sommatoria di una sola variabile, essendo una probabilità la somma vale 1 quindi posso
toglierla.
Problema delle 100 run: se ne uso solo 27 non è detto che i run mi generino l’evidenza. Se imposto N, non
è detto che le uso tutte, solitamente si rigettano quelle che vanno in contrasto con l’evidenza. Purtroppo ciò
non si può sapere a priori. Quando genero l’evidenza ed essa ha una probabilità bassa viene scartata. Una
possibile soluzione è quella di non scartare nulla (ma ciò potrebbe essere troppo pesante uno 0.1% potrebbe
essere visto come un 100%).
LIKELYHOOD WEIGHTING
Il campionamento avviene come la Rejection Sampling però quando arrivo ad uno nodo evidenza, questo
non viene campionato, viene fissato al valore osservato. In questo caso la run non la conto come realistica,
ma assegno un peso in modo da poter pesare la probabilità. La LW permette quindi di selezionare tutti i run:
Utilità attesa
Data una variabile aleatoria X={x1/p1..xk/pk} la media probabilistica di X è data da E(X) = Σ(i=1 a k) pi*xi
DECISION TREES
Decision nodes: possibili decisioni
Chance nodes: variabili probabilistiche
Value Nodes: scenario/outcome
DIAGRAMMI DI INFLUENZA
Si tratta di dei DAG con tre tipi di nodi:
chance nodes (rotondo): nodo probabilistico per ogni variabile
decision nodes (quadrato): possibili azioni
value node (esagonale): funzione di utilità espressa in forma tabellare (valore)
Caratteristiche:
Se il nodo valore ha archi entrati sono i nodi che determinano la funzione di utilità.
Se il nodo chance ha archi interni la probabilità è influenzata anche dagli altri nodi (simil Bayesian
Network).
Nel nodo decisione se c’è un arco entrante bisogna conoscere il valore del genitore (gli archi in questo
caso vengono detti informazionali).
MULTI-ATTRIBUTE UTILITY
Spesso l’utilità è definita da molti attributi, ciò comporta che bisogna assegnare troppi valori