2020-06-28 12:50:46 +02:00
|
|
|
|
* Esposito
|
|
|
|
|
** Tasks: Binary Classification
|
|
|
|
|
I modelli predittivi si occupano di inferire delle informazioni sui
|
|
|
|
|
nuove istanze di problemi in base ai dati gia` consumati
|
|
|
|
|
*** TODO Geometric classification
|
|
|
|
|
*** Probabilistic classifier
|
|
|
|
|
Stima probabilita` dai dati e fornisce predizioni usando la seguente
|
|
|
|
|
regola:
|
|
|
|
|
- Yₘₐₚ = $arg max_{Y}P(Y|X)$ = $argmax_Y\frac{(P(X|Y)(PY)}{P(X))}$ =
|
|
|
|
|
$argmax_Y\frac{(P(X|Y)(PY)}{P(Y))}$
|
|
|
|
|
- Yₘₗ = $argmax_YP(X|Y)$ (se priori non importanti)
|
|
|
|
|
*** Features
|
|
|
|
|
Se vogliamo approssimare la funzione coseno e` inutile considerare
|
|
|
|
|
un'approssimazione lineare (y=0).
|
|
|
|
|
Pero` possiamo usare x come sia come splitting feature (due
|
|
|
|
|
approssimazioni diverse se x<0 o x≥0) e come variabile di regression
|
|
|
|
|
(l'approssimazione contiene x)
|
|
|
|
|
Delle volte si puo` mappare il feature space su nuovi spazi (e.g.:
|
|
|
|
|
scatter plot: renderlo al quadrato)
|
|
|
|
|
** Classification
|
|
|
|
|
$\hat{c}$: X → C
|
|
|
|
|
C = {C₁, C₂, ..., Cₖ}
|
|
|
|
|
example: <x, c(x)>
|
|
|
|
|
Learning is constructing $\hat{c}$
|
|
|
|
|
*** TODO Decision Tree
|
|
|
|
|
Vedi decision tree, feature tree, contingency table
|
|
|
|
|
*** Misure
|
|
|
|
|
- Accuracy: $acc = \frac{1}{|T_e|}\sum I[\hat{c}(x)=c(x)] = P(\hat{c}(x) = c(x))$
|
|
|
|
|
- Error rate: $1-acc = P(\hat{c}(x) \ne c(x))$
|
|
|
|
|
- class ratio, clr: $\frac{Pos}{Neg} = \frac{\sum_{x\in{T_e}}
|
|
|
|
|
I[c(x)=1]}{\sum_{x\in{T_e}} I[c(x)=0]}$
|
|
|
|
|
- recall, true positive rate: $\frac{TP}{Pos} = P(\hat{c}(x)|c(x))$
|
|
|
|
|
- specificity, true negative rate = $\frac{TP}{Pos} =
|
|
|
|
|
P(\hat{c}(x)|c(x))$
|
|
|
|
|
- false positive, false negative = 1-tnr, 1-tpr
|
|
|
|
|
- Precision, confidence = $\frac{TP}{TP+FP} = P(c(x)|\hat{c}(x))$
|
|
|
|
|
*** TODO Coverage plot e roc plot
|
|
|
|
|
*** Scoring Classifier
|
|
|
|
|
mapping $\hat{s}: X \to R^k$ dove s e` un vettore s(x) = (s₁(x),
|
|
|
|
|
s₂(x), ..., sₖ(x)). i-th componente = score della classe Cᵢ
|
|
|
|
|
Nello scoring tree, in caso di classificazione binaria, si possono
|
|
|
|
|
usare nelle foglie il logaritmo del ratio fra lo score delle classi.
|
|
|
|
|
**** Margine e Loss f
|
|
|
|
|
Prendiamo la classe true come +1:
|
|
|
|
|
- z(x) = c(x)$\hat{s}(x)$
|
|
|
|
|
Il margine e` il valore assoluto della predizione, positivo se giusta,
|
|
|
|
|
negativo se errata.
|
|
|
|
|
La Loss function L(z(x)): R → [0, ∞); L(0) = 1 e L(z<0)≥1 e
|
|
|
|
|
L(z>0)∈[0,1)
|
|
|
|
|
La loss function e` importante nella fase di learning per cercare la
|
|
|
|
|
soluzione ottimale
|
|
|
|
|
- 0-1 Loss
|
|
|
|
|
- Hinge Loss
|
|
|
|
|
- Logistic Loss
|
|
|
|
|
- Exp Loss
|
|
|
|
|
- Squared Loss
|
|
|
|
|
**** Ranking
|
|
|
|
|
Una funzione di scoring puo` essere trasformata in una di ranking
|
|
|
|
|
ordinando le istanze in base allo score ottenuto.
|
|
|
|
|
Ranking-Error quando $\hat{s}(x)<\hat{s}(x') \wedge s(x') < s(x)$
|
|
|
|
|
- $\frac{\sum_{x\in{T^+_e},x'\in{T^-_e}}{I[\hat{s}(x) < \hat(s)(x')] +
|
|
|
|
|
I[\hat{s}(x) = \hat(s)(x')]}}{Pos\cdot Neg}$
|
|
|
|
|
- Ranking accuracy: 1 - Rank-Err
|
|
|
|
|
*** Probability Estimator
|
|
|
|
|
Scoring classifier che per ogni classe restituisce la probabilita` che
|
|
|
|
|
l'istanza appartenga a quella classe
|
|
|
|
|
- $\hat{p}: X \to [0,1]^k$
|
|
|
|
|
- $\sum_{i=1}^{k}{\hat{p_i}(x)} = 1$
|
|
|
|
|
- Squared Error: $SE(x) = \frac{1}{2} \Vert \hat{p}(x) - I_{c(x)} \Vert
|
|
|
|
|
^2_2 = \frac{1}{2}\sum_{i=1}^{k}(\hat{p}(x) - I[c(x) = C_i])^2$
|
|
|
|
|
- Mean Squared Error: $MSE(T_e) =
|
|
|
|
|
\frac{1}{|T_e|}\sum_{x\in{T_e}}SE(x)$
|
|
|
|
|
- Empirical Probability: Vettore dato dal numero di istanze sul totale
|
|
|
|
|
per ogni classe (frequenza)
|
|
|
|
|
Solitamente si applica un coefficente di smoothing per queste
|
|
|
|
|
frequenze
|
|
|
|
|
- Laplace correction: $\dot{p_i}(S) = \frac{n_i+1}{|S|+k}$
|
|
|
|
|
- m-estimate: non uniform smoothing dato da pseudo-counts m e prior
|
|
|
|
|
probs πᵢ $\dot{p_i}(S) = \frac{n_i+m\cdot\pi_i}{|S|+m}$
|
|
|
|
|
*** TODO Beyond Binary Classification
|
|
|
|
|
Vedi 1-vs-rest, 1-vs-1 e cosi` via
|
|
|
|
|
*** Overfitting, bias-variance
|
|
|
|
|
L'overfitting si evita avendo un numero di parametri ben piu` basso
|
|
|
|
|
dei data points.
|
|
|
|
|
Con un numero basso di parametri si introduce un bias che spesso anche
|
|
|
|
|
con un training elevato non si riesce a risolvere.
|
|
|
|
|
Invece con pochi parametri si introduce una forte dipendenza dal test
|
|
|
|
|
set e quindi molta varianza.
|
|
|
|
|
- $E[(f(x)-\hat{f}(x))^2] = Bias^2(\hat{f}(x)) + Var(\hat{f}(x))$
|
|
|
|
|
(vedi dimostrazione slides)
|
|
|
|
|
** Descriptive Learning
|
|
|
|
|
Tasks and learning problem coincide. No separate training set, produce
|
|
|
|
|
a descriptive model of the data at hand. Learn a model describing the
|
|
|
|
|
data.
|
|
|
|
|
*** Clustering
|
|
|
|
|
Obbiettivo: trovare gruppi omegenei, trovare una labelling function da
|
|
|
|
|
dati senza label.
|
|
|
|
|
- $\hat{q}: X \to C$ (predictive)
|
|
|
|
|
- $\hat{q}: X \to L$ (descriptive)
|
|
|
|
|
*** Supervised subgroup discovery
|
|
|
|
|
Preso un dataset labelled (xᵢ, l(xᵢ))ⁱ trova:
|
|
|
|
|
- $\hat{g}: D \to {true, false}$
|
|
|
|
|
- G = {x∈D | $\hat{g}$(x) = true}, la cui class distribution e`
|
|
|
|
|
diversa marcatamente dalla popolazione originale
|
|
|
|
|
*** Association Rules
|
|
|
|
|
Dato un dataset unlabelled D trova:
|
|
|
|
|
- un set di regole {b→h} tale che:
|
|
|
|
|
+ h solitamente e` soddisfatta quando b lo e`
|
|
|
|
|
+ b∪h e` frequente (high support: %n di elementi soddisfano la
|
|
|
|
|
regola)
|
|
|
|
|
- Il powerset di un insieme di regole frequenti e` frequente a sua
|
|
|
|
|
volta.
|
|
|
|
|
- Confidenza: support(a∪b)/suport(a)
|
|
|
|
|
** Models
|
|
|
|
|
*** Linear Models
|
2020-07-01 19:04:07 +02:00
|
|
|
|
**** Best fitting line
|
|
|
|
|
Cx + D = y
|
|
|
|
|
X w = y in matrix form, w = (C D)ᵀ
|
|
|
|
|
Se X quadrata e full rank: w = X⁻¹·y ma generalmente X non e`
|
|
|
|
|
invertibile
|
|
|
|
|
| Errore: ‖e‖₂ = ‖y-p‖₂ = (∑ᵢ(yᵢ-pᵢ)²)⁻¹
|
|
|
|
|
Possiamo inquadrare questo problema come un problema di minimizzazione
|
|
|
|
|
della norma di e. p = X·$\hat{w}$: L'intero problema consiste in:
|
|
|
|
|
| $minimize_{\hat{w}}\Vert X \hat{w} - y \Vert_2^2$
|
2020-07-02 11:58:47 +02:00
|
|
|
|
| minimize_ŵ ‖Xŵ-y‖²₂
|
2020-07-01 19:04:07 +02:00
|
|
|
|
La soluzione consiste nell'imporre l'ortogonalita` di e e C(X), ovvero
|
|
|
|
|
Xᵀ·e=0; quindi:
|
|
|
|
|
| Xᵀ·e = 0; e = y-X·ŵ
|
|
|
|
|
| Xᵀ(y-X·ŵ) = 0
|
|
|
|
|
| Xᵀy = XᵀXŵ
|
2020-07-02 11:58:47 +02:00
|
|
|
|
| ŵ = (XᵀX)⁻¹Xᵀy (LSE)
|
2020-07-01 19:04:07 +02:00
|
|
|
|
**** Regularization
|
|
|
|
|
evitare l'overfitting applicando dei constraint sul weight vector.
|
|
|
|
|
Generalmente i pesi sono in media piccoli: ~shrinkage~.
|
|
|
|
|
La versione regolarizzata di LSE:
|
|
|
|
|
| w* = argmin_w (y-X·w)ᵀ(y-X·w) + λ‖w‖₂
|
|
|
|
|
Soluzione:
|
|
|
|
|
| ŵ = (XᵀX + λI)⁻¹Xᵀy
|
|
|
|
|
si dice ~ridge regression~ e significa aggiungere λ alla diagonale di
|
|
|
|
|
XᵀX per migliorare la stabilita` numerica dell'inversione
|
|
|
|
|
Si puo` anche usare ~lasso~ nel caso di soluzioni sparse
|
|
|
|
|
(least absolute shrinkage and selection operator)
|
|
|
|
|
che sostituisce ‖w‖₂ con ‖w‖₁=∑|wᵢ|
|
2020-07-02 11:58:47 +02:00
|
|
|
|
| w* = argmin_w (y-X·w)ᵀ(y-X·w) + λ‖w‖₁
|
2020-07-01 19:04:07 +02:00
|
|
|
|
Minimizzare la norma significa immaginare che X sia affetto da errore
|
|
|
|
|
D e minimizzare l'errore:
|
|
|
|
|
| (X+D)w = Xw + Dw
|
|
|
|
|
inoltre significa imporre un bias e quindi minimizzare l'effetto della
|
|
|
|
|
varianza dell'errore. LSE enhance le piccole variazioni nei dati:
|
|
|
|
|
unstable regressor.
|
|
|
|
|
**** LSE per la classificazione
|
|
|
|
|
| ĉ(x) = 1 se xᵀŵ - t > 0
|
|
|
|
|
| ĉ(x) = 0 se xᵀŵ - t = 0
|
|
|
|
|
| ĉ(x) = -1 se xᵀŵ - t < 0
|
|
|
|
|
Ovvero si rappresenta la classe positiva come 1 e la negativa come -1
|
|
|
|
|
t rappresenta gli intercepts.
|
|
|
|
|
** SVM
|
|
|
|
|
Hyperplane:
|
|
|
|
|
| y = ax + b
|
|
|
|
|
| y -ax -b = 0
|
|
|
|
|
| wᵀx = 0
|
|
|
|
|
- w = (-b -a 1)ᵀ *x* = (1 x y)ᵀ
|
|
|
|
|
- Functional margins: soluzioni che non fanno errori
|
|
|
|
|
- Geometric margins: soluzioni che massimizzano la distanza fra i piu`
|
|
|
|
|
vicini punti di classe opposta
|
|
|
|
|
*** Margine funzionale
|
|
|
|
|
Valore dell'hyperplane al punto xᵢ:
|
|
|
|
|
| f(xᵢ) = w·xᵢ-t
|
|
|
|
|
possiamo usare f(xᵢ)>0 per discriminare fra classe positiva/negativa
|
|
|
|
|
- Functional margin:
|
|
|
|
|
| μ(xᵢ) = yᵢ(w·xᵢ-t) = yᵢf(xᵢ)
|
|
|
|
|
se l'esempio e` ben classificato: μ(xᵢ) > 0
|
|
|
|
|
*** Support Vectors
|
|
|
|
|
Possiamo richiedere che ogni istanza nel dataset soddisfi:
|
|
|
|
|
| yᵢ(w·xᵢ-t) ≥ 1
|
|
|
|
|
Istanze nel decision boundary (chiamate ~support vectors~):
|
|
|
|
|
| yᵢ(w·xᵢ-t) = 1
|
|
|
|
|
Margine geometrico:
|
|
|
|
|
(x₊-x₋)·$\frac{w}{\Vert{w}\Vert}$
|
|
|
|
|
*** TODO (w₀,w₁) ortogonali
|
|
|
|
|
*** Ottimizzazione:
|
|
|
|
|
Margin size:
|
|
|
|
|
| μ = (x₊-x₋)·w/‖w‖
|
|
|
|
|
| x₊·w-t = 1 -> x₊·w = 1+t
|
|
|
|
|
| -(x₋·w-t) = 1 -> x₋·w = t-1
|
|
|
|
|
| $\mu = \frac{1+t-(t-1)}{\Vert{w}\Vert} = \frac{2}{\Vert{w}\Vert}$
|
|
|
|
|
μ va minimizzata, il che significa massimizzare ‖w‖
|
|
|
|
|
| $minimize_{w,t} \frac{1}{2}\Vert{w}\Vert^{2}$
|
|
|
|
|
| yᵢ(w·xᵢ-t)≥1; 0≤i≤n
|
|
|
|
|
minimizzaₓ: f₀(x)
|
|
|
|
|
soggetto a: fᵢ(x) ≤ 0 i = 1, ..., m
|
|
|
|
|
gᵢ(x) = 0 i = 1, ..., p
|
|
|
|
|
Formulazione duale di Lagrange:
|
|
|
|
|
| g(α, υ) = infₓ ⋀(x,α,υ) = infₓ(f₀(x) + ∑₁ᵐαᵢfᵢ(x) + ∑₁ᵖυᵢgᵢ(x))
|
|
|
|
|
Duality: forma organizzata per per formare bound non triviali in un
|
|
|
|
|
problema di ottimizzazione
|
|
|
|
|
In problemi convessi il bound e` solitamente ~strict~ e massimizzare
|
|
|
|
|
il bound porta alla stessa soluzione che minimizzare la funzione
|
|
|
|
|
originale: ~strong duality~.
|
|
|
|
|
KKT conditions needs to hold for strong duality.
|
|
|
|
|
TODO: Vedi dimostrazione slides
|
|
|
|
|
|
|
|
|
|
** Kernels
|
|
|
|
|
Trick usato per adattare degli algoritmi lineari a ipotesi non
|
|
|
|
|
lineari.
|
|
|
|
|
Idea: linear decision surface su uno spazio trasformato puo`
|
|
|
|
|
corrispondere ad una superficie non lineare sullo spazio originale.
|
|
|
|
|
Esempio:
|
|
|
|
|
| ϕ(x) = (x₁², sqrt(2)x₁x₂, x₂², c)
|
|
|
|
|
| ĉ(x) = sign(w·x-t)
|
|
|
|
|
| ĉ(x) = sign(K(w,x)-t) = sign(ϕ(w)·ϕ(x)-t)
|
|
|
|
|
|
|
|
|
|
Una kernel function K: V×V→R per la quale esiste un mapping ϕ:V→F, F
|
|
|
|
|
spazio di Hilbert, tale che:
|
|
|
|
|
K(x,y) = <ϕ(x), ϕ(y)>
|
|
|
|
|
Ovvero una kernel function calcola l'inner product di x e y dopo
|
|
|
|
|
averli mappati su un nuovo spazio di Hilbert (possibilmente highly
|
|
|
|
|
dimensional)
|
|
|
|
|
|
|
|
|
|
Restituiscono un intuizione della similarita` (proporzionalmente)
|
|
|
|
|
**** TODO Mercer condition
|
|
|
|
|
**** Inner product
|
|
|
|
|
generalizzazione del dot product su piu` spazi.
|
|
|
|
|
| Simmetrico: <x,y> = <y,x>
|
|
|
|
|
| lineare sul primo argomento: <ax+by,z> = a<x,z> + b<y,z>
|
|
|
|
|
| definito positivamente: <x,x>≥0; <x,x> = 0 ⇔ x = 0
|
|
|
|
|
Comodi perche`:
|
|
|
|
|
- linear classifier possono lavorare su problemi non lineari
|
|
|
|
|
- similarity function in highly dim. space senza calcolare i feature
|
|
|
|
|
vectors
|
|
|
|
|
- composizione, nuovi kernel da vecchi
|
|
|
|
|
|
|
|
|
|
**** Kernel importanti
|
|
|
|
|
Polinomiale:
|
|
|
|
|
K(x,y) = (x·y)ᵈ or K(x,y) = (x·y+1)ᵈ
|
|
|
|
|
- d = 1 → identity
|
|
|
|
|
- d = 2 → quadratic
|
|
|
|
|
- feature space esponenziale in d
|
|
|
|
|
|
|
|
|
|
Gaussian Kernel:
|
|
|
|
|
$K(x,y) = exp(-\frac{\Vert{x-y}\Vert^2}{2\sigma}$
|
|
|
|
|
σ e` deciso tramite cross validation su un altro set indipendente
|
|
|
|
|
il feature space ha dimensionalita` infinita.
|
|
|
|
|
|
2020-06-28 12:50:46 +02:00
|
|
|
|
* Meo
|
2020-07-01 19:04:07 +02:00
|
|
|
|
** Concept learning
|
|
|
|
|
Assunto base: ogni ipotesi che approssima bene la target function
|
|
|
|
|
sugli esempi di training, approssimera` bene anche la target function
|
|
|
|
|
con esempi mai visti.
|
|
|
|
|
Inoltre D e` consistente e senza rumori ed esiste un'ipotesi h che
|
|
|
|
|
descrive il target concept c.
|
|
|
|
|
Un'ipotesi h e` una congiunzione di constraint sugli attributi.
|
|
|
|
|
Il numero delle ipotesi e` esponenzialmente largo sul numero delle
|
|
|
|
|
features:
|
|
|
|
|
| {codominio funzione}^{n distinte istanze}
|
|
|
|
|
- Ipotesi piu` generale:
|
|
|
|
|
siano hⱼ, hₖ due funzioni booleane (ipotesi) definite su X.
|
|
|
|
|
Si dice che hⱼ e` almeno generale quanto hₖ, scritto hⱼ≥hₖ iff
|
|
|
|
|
| ∀x∈X: hₖ(x) = 1 → hⱼ(x) = 1
|
|
|
|
|
La relazione ≥ impone un ordine parziale (rifl, trans, antisimm).
|
|
|
|
|
- Version Space:
|
|
|
|
|
Si chiama version space il set delle ipotesi consistenti con il dataset.
|
|
|
|
|
*** Algoritmo Find-S
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
h ← most specific hyp. in H
|
|
|
|
|
foreach x∈X:
|
|
|
|
|
foreach aⱼ in h: (attribute constraint)
|
|
|
|
|
if h(x)⊧aⱼ:
|
|
|
|
|
continue
|
|
|
|
|
else:
|
|
|
|
|
h ← next more general hyp that satisfies aⱼ
|
|
|
|
|
output h
|
|
|
|
|
#+END_SRC
|
|
|
|
|
Advantages:
|
|
|
|
|
- Hyp. space defined through conjunction of constraints
|
|
|
|
|
- will output most specific hyp. that is consistent
|
|
|
|
|
- will be consistent with negative examples as well
|
|
|
|
|
Svantaggi:
|
|
|
|
|
- non si sa se il learner converge al target concept (non sa se e`
|
|
|
|
|
l'unica ipotesi valida)
|
|
|
|
|
- non sa se il training data e` consistente: ignora esempi negativi
|
|
|
|
|
*** Version Space
|
|
|
|
|
Definiamo il Version Space come:
|
|
|
|
|
| VSₕ_D = {h∈H|Consistent(h,D)}
|
|
|
|
|
| Consistent(h,D) = ∀<x,c(x)>∈D: h(x) = c(x)
|
|
|
|
|
General and specific boundary of VS: set of maximally g/s members
|
|
|
|
|
| VSₕ_D = {h∈H| ∃s∈S, ∃g∈G: g≥h≥s}
|
|
|
|
|
**** List then Eliminate
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
Version Space ← list of every hyp. in H
|
|
|
|
|
foreach <x,c(x)> in X:
|
|
|
|
|
foreach h in Version Space:
|
|
|
|
|
if h(x) ≠ c(x) : remove h from VS
|
|
|
|
|
output VS
|
|
|
|
|
#+END_SRC
|
|
|
|
|
**** Candidate Elimination
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
G ← max. general hyp.
|
|
|
|
|
S ← max. specific hyp.
|
|
|
|
|
foreach d=<x,c(x)> ∈ D:
|
|
|
|
|
if d is ⊕:
|
|
|
|
|
remove from G any inconsistent hyp.
|
|
|
|
|
foreach inconsistent hyp. s in S:
|
|
|
|
|
remove s from S
|
|
|
|
|
add to S all minimal generalizations h of s:
|
|
|
|
|
- h consistent with d
|
|
|
|
|
- some members of G is more general than h
|
|
|
|
|
- S is a summary of all members cons. with positive examples
|
|
|
|
|
remove from S any hyp. more general than other hyp. in S
|
|
|
|
|
if d is ⊖:
|
|
|
|
|
remove from S any inconsistent hyp.
|
|
|
|
|
foreach inconsistent hyp. g in G:
|
|
|
|
|
remove g from G
|
|
|
|
|
add to G all minimal generalizations h of g:
|
|
|
|
|
- h consistent with d
|
|
|
|
|
- some members of S is more general than h
|
|
|
|
|
- G is a summary of all members cons. with negative examples
|
|
|
|
|
remove from G any hyp. more general than other hyp. in G
|
|
|
|
|
#+END_SRC
|
|
|
|
|
- converge allo stesso VS qualsiasi l'ordine iniziale di D
|
|
|
|
|
- puo` convergere a VS diversi se non ci sono abbastanza membri nel
|
|
|
|
|
training set
|
|
|
|
|
**** Inductive Leap
|
|
|
|
|
Assumiamo che H contenga il target concept c. Ovvero che c puo` essere
|
|
|
|
|
descritto tramite una congiunzione di literals.
|
|
|
|
|
Unbiased learner: H esprime ogni concetto imparabile, ovver
|
|
|
|
|
Powerset(X).
|
|
|
|
|
S e G sono i due insiemi ⊕ ⊖ (con congiunzioni logiche, vedi slides).
|
|
|
|
|
Futile perche` un learner che non fa assunzioni a priori
|
|
|
|
|
sull'identita` del target concept non ha basi per classificare istanze
|
|
|
|
|
mai viste.
|
|
|
|
|
- Bias induttivo:
|
|
|
|
|
| ∀xᵢ∈X: (B ∧ D_c ∧ xᵢ) ⊧ L(xᵢ,D_c)
|
|
|
|
|
L(xᵢ, D_c) e` la classificazione assegnata dal concept learning
|
|
|
|
|
algorithm L dopo il training su D_c
|
|
|
|
|
Permette di trasformare un sistema induttivo in deduttivo
|
|
|
|
|
** TODO Path Through hyp. space
|
|
|
|
|
Vedi che vuole sapere
|
2020-07-03 19:08:23 +02:00
|
|
|
|
** TODO Trees (manca ranking e regression trees)
|
|
|
|
|
I decision tree sono molto espressivi e corrispondono a proposizioni
|
|
|
|
|
logiche in DNF.
|
|
|
|
|
Per evitare l'overfitting bisogna introdurre scegliendo un linguaggio
|
|
|
|
|
restrittivo per le ipotesi e penalizzando la complessita` di ogni
|
|
|
|
|
ipotesi nella funzione target.
|
|
|
|
|
*** Feature tree
|
|
|
|
|
Nei feature tree ogni nodo interno e` segnato con una feature e ogni
|
|
|
|
|
arco con un literal.
|
|
|
|
|
L'insieme dei literals in un nodo e` chiamato ~split~.
|
|
|
|
|
Dalle foglie possiamo costruire un'espressione logica tramite
|
|
|
|
|
congiunzione dei literals risalendo alla root.
|
|
|
|
|
Il set di istanze coperto dall'espressione e` chiamato ~instance space
|
|
|
|
|
segment~.
|
|
|
|
|
Tree learners eseguono una ricerca top-down di tutti i concetti.
|
|
|
|
|
*** Algoritmo Grow Tree
|
|
|
|
|
Procedura generica
|
|
|
|
|
- Homogeneous: D → bool; true if hom. enough to be labelled with a
|
|
|
|
|
single label
|
|
|
|
|
- Label: D → label; most appropriate label for a set of instances
|
|
|
|
|
- BestSplit: D×F → set of literals; best set of literals to be put at the
|
|
|
|
|
root of the tree
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
Input: Dataset D, set of features F
|
|
|
|
|
if Homogeneous(D) then return Label(D)
|
|
|
|
|
S ← BestSplit(D, F)
|
|
|
|
|
split D in Dᵢ secondo i literals in S
|
|
|
|
|
foreach i do:
|
|
|
|
|
if Dᵢ ≠ ∅ then Tᵢ ← GrowTree(Dᵢ, F)
|
|
|
|
|
else Tᵢ is a leaf labelled with Label(D)
|
|
|
|
|
|
|
|
|
|
return tree whose root is labelled with S and whose children are Tᵢ
|
|
|
|
|
#+END_SRC
|
|
|
|
|
|
|
|
|
|
*** Purity
|
|
|
|
|
La bonta` di uno split e` determinata dalla purezza.
|
|
|
|
|
Per esempio nel caso di due classi ⊕ e ⊖, la purezza puo` essere
|
|
|
|
|
definita in termini di probabilita` empirica.
|
|
|
|
|
La purezza misura i figli negli alberi, in rule learning la purezza e`
|
|
|
|
|
di un solo figlio il literal e` true. Si possono usare le purity
|
|
|
|
|
measure degli alberi ma senza bisogno di fare la media.
|
|
|
|
|
In the case of classes:
|
|
|
|
|
| minority-class: min{p̣, 1-p̣}
|
|
|
|
|
| Gini-index: ∑p̣ᵢ(1-p̣ᵢ); expected error rate if examples on leaves were labelled randomly
|
|
|
|
|
| Entropy: -∑p̣ᵢ·log₂(p̣ᵢ)
|
|
|
|
|
Impurity of a set: $Imp(D_1, D_2, ..., D_l) = \sum_{j=1}^l
|
|
|
|
|
\frac{|D_j|}{|D|} Imp(D_j)$
|
|
|
|
|
*** Decision Trees
|
|
|
|
|
Separa il dataset in partizioni disgiunte usando l'objective function
|
|
|
|
|
(ogni partizione e` pura nel suo target attribute).
|
|
|
|
|
L'objective function misura la purezza delle partizioni ottenute dopo
|
|
|
|
|
lo split.
|
|
|
|
|
- Information of an event
|
|
|
|
|
I(E) = log₂(1/p)
|
|
|
|
|
Se un evento e` molto probabile (p≊1), l'informazione che ne ricaviamo e`
|
|
|
|
|
poca, e viceversa.
|
|
|
|
|
Se un esperimento ha n outcomes ognuno con probabilita` pᵢ la
|
|
|
|
|
quantita` di informazione media ricavata e` esattamente l'entropia:
|
|
|
|
|
| ∑pᵢlog₂(1/pᵢ) = -∑pᵢlog₂(pᵢ)
|
|
|
|
|
**** BestSplit-Class Algorithm
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
input: dataset D, set of features F
|
|
|
|
|
Iₘᵢₙ ← 1
|
|
|
|
|
foreach f∈F:
|
|
|
|
|
split D into subsets D₁,...,Dₗ secondo i valori υⱼ of f
|
|
|
|
|
if Imp({D₁, ..., Dₗ}) < Iₘᵢₙ:
|
|
|
|
|
Iₘᵢₙ ← Imp({D₁, ..., Dₗ})
|
|
|
|
|
f_{best} ← f
|
|
|
|
|
return f_{best} (feature f to split on)
|
|
|
|
|
#+END_SRC
|
|
|
|
|
Il best split minimizza l'impurita` dei subset D₁, ..., Dₗ.
|
|
|
|
|
*** TODO Ranking Trees
|
|
|
|
|
- Spazio diviso in segmenti
|
|
|
|
|
- Gli alberi possono diventare rankers se imparano un ordinamento per
|
|
|
|
|
i segmenti
|
|
|
|
|
- Le foglie devono essere ordinate
|
|
|
|
|
|
2020-07-01 19:04:07 +02:00
|
|
|
|
** Rules
|
|
|
|
|
Ordered rules are a chain of /if-then-else/.
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
1. Keep growing the rule antecedent by literal conjunction (high purity)
|
|
|
|
|
2. Select the label as the rule consequent
|
|
|
|
|
3. Delete the instance segment from the data, restart from 1
|
|
|
|
|
#+END_SRC
|
2020-07-03 19:08:23 +02:00
|
|
|
|
|
|
|
|
|
*** LearnRuleList
|
|
|
|
|
learn an ordered list of rules
|
|
|
|
|
- LearnRuleList:
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
Input: Labelled training dataset D
|
|
|
|
|
R ← ∅
|
|
|
|
|
while D ≠ ∅ :
|
|
|
|
|
r ← LearnRule(D)
|
|
|
|
|
append r to end of R
|
|
|
|
|
D ← D \ {x∈D | x is covered by r}
|
|
|
|
|
return R
|
|
|
|
|
#+END_SRC
|
|
|
|
|
- LearnRule(D):
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
b ← true
|
|
|
|
|
L ← set of available literals
|
|
|
|
|
while not Homogeneous(D):
|
|
|
|
|
l ← BestLiteral(D,L)
|
|
|
|
|
b ← b ∧ l
|
|
|
|
|
D ← {x∈D | x is covered by b}
|
|
|
|
|
L ← L \ {l'∈L | l' uses same fetures as l}
|
|
|
|
|
C ← Label(D)
|
|
|
|
|
r ← if b then Class = C
|
|
|
|
|
return r
|
|
|
|
|
#+END_SRC
|
|
|
|
|
*** Unordered rules
|
|
|
|
|
Rules can also refer to the same class and we can collect them in a
|
|
|
|
|
rule set.
|
|
|
|
|
- LearnRuleSet(D):
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
Input: Labelled training data D
|
|
|
|
|
R ← ∅
|
|
|
|
|
for every class Cᵢ :
|
|
|
|
|
Dᵢ ← D
|
|
|
|
|
while Dᵢ contains examples of class Cᵢ:
|
|
|
|
|
r ← LearnRuleForClass(Dᵢ, Cᵢ)
|
|
|
|
|
R ← R ∪ {r}
|
|
|
|
|
Dᵢ ← Dᵢ \ {x∈Cᵢ | x is covered by r} ;; remove only positives
|
|
|
|
|
return R
|
|
|
|
|
#+END_SRC
|
|
|
|
|
- LearnRuleForClass(Dᵢ, Cᵢ):
|
|
|
|
|
Stesso che LearnRule(D) ma usa Cᵢ invece che C←Label(D).
|
|
|
|
|
Il problema con queste regole e` che si concentrano troppo sulla
|
|
|
|
|
purezza quando ci sono regole quasi pure che pero` non possono essere
|
|
|
|
|
generalizzate: usa lo smoothing.
|
|
|
|
|
- Laplace correction: $\dot{p}_i^+ = \frac{n_i^+ + 1}{n_i + 2}$
|
|
|
|
|
Solitamente rulesets hanno una performance di ranking maggiore (n
|
|
|
|
|
contro 2ⁿ istanze riconoscibili) ma possono restituire una curva di
|
|
|
|
|
coverage non convessa.
|
|
|
|
|
** TODO Subgroup discovery
|
|
|
|
|
I sottogruppi sono un subset dell'instance space la cui class
|
|
|
|
|
distribution e` differente da quella di D.
|
|
|
|
|
Mapping ĝ: X → C; D = (xᵢ, l(xᵢ))ⁱ
|
2020-07-04 19:00:26 +02:00
|
|
|
|
** Distance models
|
|
|
|
|
La distanza e` una misura di similarita`: minore la distanza, maggiore
|
|
|
|
|
la similarita`.
|
|
|
|
|
Se X∈Rᵈ definiamo la Minkowsi distance: $Dis_p(x,y) =
|
|
|
|
|
(\sum_{j=1}^{d}{|x_j-y_j|^p})^{\frac{1}{p}} = \Vert{x-y}\Vert_p$ (‖z‖
|
|
|
|
|
e` la p-norm).
|
|
|
|
|
- Se p = 2 -> distanza euclidea.
|
|
|
|
|
| Dis₂(x,y) = sqrt ((x-y)ᵀ(x-y))
|
|
|
|
|
- Manhattan:
|
|
|
|
|
| Dis₁(x,y) = ∑|xⱼ-yⱼ|
|
|
|
|
|
- Chebyshev: $Dis_{\infty}(x,y) = max_j|x_j-y_j|$
|
|
|
|
|
- 0-norm:
|
|
|
|
|
| ∑ I[xⱼ≠yⱼ]
|
|
|
|
|
- Jaccard distance for aysmmetric problems
|
|
|
|
|
- Mahalanobis (elliptical?): $Dis_M(x,y|\sum) = \sqrt{
|
|
|
|
|
(x-y)^T\sum^-1(x-y) }$
|
|
|
|
|
Dis₂ = Disₘ quando ∑ e` l'identity matrix. Normalmente ∑ e`
|
|
|
|
|
l'inverso della matrice di covarianza: M = ∑⁻¹.
|
|
|
|
|
La distanza di Mahal. tiene conto della distanza fra le features e
|
|
|
|
|
grazie a ∑ riduce le distanze nella direzione di spread.
|
|
|
|
|
Generalizzando:
|
|
|
|
|
Dato un'instance space X una metrica della distanza Dis: X×X→R e` tale
|
|
|
|
|
che ∀x,y,z∈X:
|
|
|
|
|
- Dis(x,x) = 0
|
|
|
|
|
- Dis(x,y) > 0 if x≠y
|
|
|
|
|
- Dis(x,y) = Dis(y,x)
|
|
|
|
|
- Dis(x,z) ≤ Dis(x,y) + Dis(y,z) (no detours)
|
|
|
|
|
*** Distanze e medie
|
|
|
|
|
Si dimostra (slide 343) che μ e` il punto nello spazio Euclideo che ha
|
|
|
|
|
∑distanza minimo.
|
|
|
|
|
Il centroide rispetto al medioide puo` anche essere un punto fittizio.
|
|
|
|
|
Un classificatore lineare molto basico si puo` costruire classificando
|
|
|
|
|
ogni istanza.
|
|
|
|
|
*** KNN
|
|
|
|
|
A KNN cls takes a vote for each of the k nearest exemplars and
|
|
|
|
|
predicts the class.
|
|
|
|
|
In pratica il cls prendere k voti dai piu` vicini. All'aumentare di K
|
|
|
|
|
aumenta il bias e diminuisce la varianza. Con basso k sono simili ad aggregatori.
|
|
|
|
|
Non efficienti negli spazi con molte dimensioni.
|
|
|
|
|
I voti possono anche essere pesati in base alle distanze.
|
|
|
|
|
*** DBScan
|
|
|
|
|
Usare NN non per la predizione ma per la classificazione.
|
|
|
|
|
- Density: numero di punti nel raggio ~Eps~
|
|
|
|
|
- Core point: ha minimo ~MinPts~ nel raggio (interior del cluster)
|
|
|
|
|
- Border point: meno di MinPts punti in Eps, ma vicino di CorePoint
|
|
|
|
|
- Noise point: ne` border point ne core point.
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
Label all point as Core, Border, Noise
|
|
|
|
|
Elimina i Noise points
|
|
|
|
|
Metti un arco fra i core-points nel raggio Eps l'uno dall'altro
|
|
|
|
|
- ogni gruppo di punti connessi e` un cluster
|
|
|
|
|
Assegna ogni Border point ad un cluster
|
|
|
|
|
#+END_SRC
|
|
|
|
|
Buono per classificare cluster di differente grandezza e forma.
|
|
|
|
|
Non funziona bene sulle densita` variabili e sui punti ad alta
|
|
|
|
|
dimensionalita`.
|
|
|
|
|
*** Misure
|
|
|
|
|
- Coesione: quanto gli oggetti son closely related nel cluster
|
|
|
|
|
- Separazione: quanto distinto o ben separato il cluster dagli altri
|
|
|
|
|
Dato Sum of Squared Error
|
|
|
|
|
- Within cluster Sum of Squares: $WSS = \sum_i \sum_{x\in
|
|
|
|
|
C_i}(x-m_i)^2$
|
|
|
|
|
- Between cluster Sum of Squares: $BSS = \sum_i |C_i|(m-m_i)^2$
|
|
|
|
|
BSS + WSS e` costante. Il problema dei K-Means consiste nel trovare
|
|
|
|
|
una soluzione che minimizza WSS (o massimizza BSS): cluster coesi.
|
|
|
|
|
*** Algoritmo di LLoyd
|
|
|
|
|
- Itera partizionando in base al centroide e ricalcola il centroide.
|
|
|
|
|
- Converge ad un punto stazionario ma non garantisce che la soluzione
|
|
|
|
|
sia il minimo globale.
|
|
|
|
|
- KMeans(K,D) usando Dis₂
|
|
|
|
|
#+BEGIN_SRC
|
|
|
|
|
Input data D⊆Rᵈ; numero di cluster k.
|
|
|
|
|
Inizializza casualmente K vettori μ₁, ..., μₖ ∈Rᵈ
|
|
|
|
|
do:
|
|
|
|
|
assegna ogni x∈D a argminⱼ Dis₂(x,μⱼ)
|
|
|
|
|
for j = 1 to k:
|
|
|
|
|
Dⱼ ← {x∈D| x assigned to cluster j}
|
|
|
|
|
μⱼ = 1/|Dⱼ| ∑x (x∈Dⱼ)
|
|
|
|
|
until (no change in μ₁, ..., μₖ
|
|
|
|
|
ritorna μ₁, ..., μₖ
|
|
|
|
|
#+END_SRC
|