martedì 1 agosto 2017

selfies


tratativa de selfie
operacion selfie

interrupcion de lectura

mercoledì 7 giugno 2017

Pratical Maching Learning 3

  Trasformazioni: Ingegnerizzazione dell'ingresso e dell'uscita
    Transformations: Engineering the input and output


 Nel capitolo precedente abbiamo esaminato una vasta gamma di metodi di apprendimento macchina: alberi decisionali, regole decisionali, modelli lineari, schemi basati su istanze, tecniche di previsione numerica, algoritmi di clustering e reti bayesiane. Tutte sono solide e robuste tecniche che sono eminentemente applicabili ai problemi pratici di data mining. Ma la riuscita data mining richiede molto di più di selezionare un algoritmo di apprendimento e di eseguirlo sui dati. Per prima cosa, molti metodi di apprendimento hanno diversi parametri e devono essere scelti valori adeguati. Nella maggior parte dei casi, i risultati possono essere migliorati notevolmente mediante una scelta appropriata dei valori dei parametri e la scelta appropriata dipende dai dati in questione. Ad esempio, gli alberi decisionali possono essere piantati o non eseguiti e nel primo caso è necessario scegliere un parametro di potatura. Nel metodo k-nearest-neighbor-neighbor di apprendimento basato su istanze, dovrà essere scelto un valore per k. Più in generale, lo schema di apprendimento stesso deve essere scelto dalla gamma di schemi disponibili. In ogni caso, le scelte giuste dipendono dai dati stessi.

   È tentato di provare diversi schemi di apprendimento e di diversi valori dei parametri sui tuoi dati e vedere quali funzionano meglio. Ma fa attenzione! La scelta migliore non è necessariamente quella che esegue meglio i dati formativi. Abbiamo ripetutamente avvertito il problema dell'overfitting, dove un modello appreso è troppo strettamente legato ai particolari dati formativi da cui è stato costruito. Non è corretto supporre che le prestazioni sui dati di addestramento rappresentino fedelmente il livello di prestazione che si può aspettare sui nuovi dati a cui il modello appreso verrà applicato in pratica.


  Fortunatamente, abbiamo già incontrato la soluzione a questo problema nel capitolo 5. Ci sono due buoni metodi per valutare le prestazioni previste di uno schema di apprendimento: l'uso di un grande set di dati che è abbastanza separato dai dati formativi, nel caso di Dati abbondanti e convalida incrociata (sezione 5.3), se i dati sono scarsi. In quest'ultimo caso, in pratica viene utilizzata una sola convalida incrociata di 10 volte, anche se per ottenere una stima più attendibile, l'intera procedura deve essere ripetuta 10 volte. Una volta scelti i parametri idonei per il programma di apprendimento, utilizzare l'intero set di formazione - tutti i percorsi di formazione disponibili - per produrre il modello finale appreso che deve essere applicato a dati freschi.

  Si noti che le prestazioni ottenute con il valore del parametro selezionato durante il processo di sintonizzazione non sono una stima attendibile della performance del modello finale, poiché il modello finale potenzialmente sovrascrive i dati utilizzati per la sintonizzazione. Per accertare quanto sarà efficace, è necessario un altro set di dati di grandi dimensioni che è abbastanza separato da tutti i dati utilizzati durante l'apprendimento e l'accordatura. Lo stesso vale per la convalida incrociata: è necessaria una convalida incrociata per la parametrizzazione e una convalida incrociata esterna per la stima degli errori. Con una convalida incrociata di 10 volte, ciò comporta l'esecuzione dello schema di apprendimento 100 volte. Riassumendo: nel valutare le prestazioni di un sistema di apprendimento, qualsiasi parametrizzazione che va avanti dovrebbe essere trattata come se fosse parte integrante del processo di formazione.


  Ci sono altri importanti processi che possono migliorare notevolmente il successo quando si applicano le tecniche di apprendimento delle macchine ai problemi pratici di data mining e sono oggetto di questo capitolo. Essi costituiscono una sorta di ingegneria dei dati: ingegnerizzazione dei dati di input in una forma adatta allo schema di apprendimento scelto e ingegnerizzazione del modello di output per renderlo più efficace. Puoi guardarli come un sacco di trucchi che puoi applicare ai problemi pratici di estrazione dei dati per aumentare la probabilità di successo. A volte funzionano; Altre volte non lo fanno - e allo stato attuale dell'arte, è difficile dire in anticipo se vogliono o no. In una zona come questa dove il processo e l'errore è la guida più affidabile, è particolarmente importante essere impegnativi e capire quali sono i trucchi.

   Iniziamo esaminando quattro modi diversi in cui l'input può essere massaggiato per renderlo più appropriato per i metodi di apprendimento: selezione degli attributi, discretizzazione degli attributi, trasformazione dei dati e pulizia dei dati. Si consideri la prima selezione degli attributi. In molte situazioni pratiche ci sono troppi attributi per i sistemi di apprendimento da gestire e alcuni di loro - forse la stragrande maggioranza - sono chiaramente irrilevanti o ridondanti. Di conseguenza, i dati devono essere elaborati per selezionare un sottoinsieme degli attributi da utilizzare nell'apprendimento. Naturalmente, i metodi di apprendimento stessi provano a selezionare gli attributi in modo appropriato e ignorano quelli irrilevanti o ridondanti, ma in pratica la loro prestazione può essere spesso migliorata tramite la preselezione. Ad esempio, gli esperimenti mostrano che l'aggiunta di attributi inutili provoca la deteriorazione della performance di schemi di apprendimento come gli alberi decisionali e le regole, la regressione lineare, gli studenti basati sull'istanza e i metodi di cluster.


   La discretizzazione degli attributi numerici è assolutamente indispensabile se l'attività comporta attributi numerici ma il metodo di apprendimento scelto può trattare solo quelli categorici. Anche i metodi che possono gestire gli attributi numerici spesso producono risultati migliori o funzionano più velocemente se gli attributi sono predisposti. La situazione conversa, in cui gli attributi categorici devono essere rappresentati numericamente, si verifica anche se meno spesso; E descriviamo anche tecniche per questo caso. La trasformazione dei dati copre una varietà di tecniche. Una trasformazione, che abbiamo incontrato prima, quando si esamina i dati relazionali del Capitolo 2 e le macchine vettoriali di supporto nel Capitolo 6, è aggiungere nuovi attributi sintetici il cui scopo è quello di presentare le informazioni esistenti in una forma adatta all'apprendimento macchina, Schema per "raccogliere". Tecniche più generali che non dipendono così intimamente dalla semantica del particolare problema di data mining a portata di mano includono analisi dei componenti principali e proiezioni casuali.

    I dati impuri innescano l'estrazione dei dati. Abbiamo sottolineato nel capitolo 2 la necessità di conoscere i tuoi dati: comprendere il significato di tutti i diversi attributi, le convenzioni utilizzate per codificarle, il significato dei valori mancanti e i dati duplicati, i rumori di misura, gli errori tipografici e la presenza di sistemi Errori, anche quelli deliberati. Molte semplici visualizzazioni spesso aiutano con questo compito. Ci sono anche metodi automatici di pulizia dei dati, di rilevamento di outliers e di individuazione di anomalie, che descriviamo.

  Dopo aver studiato come massaggiare l'input, ci rivolgiamo alla questione dell'ingegnere l'output dei sistemi di apprendimento macchina. In particolare esaminiamo tecniche per combinare diversi modelli appresi dai dati. Ci sono alcune sorprese in negozio. Ad esempio, spesso è vantaggioso prendere i dati formativi e ottenere diversi set di formazione da lui, imparare un modello da ciascuno e combinare i modelli risultanti! Infatti, le tecniche per farlo possono essere molto potenti. È ad esempio possibile trasformare un metodo relativamente debole di apprendimento in un aspetto estremamente forte (in un preciso senso che spiegheremo). Inoltre, se sono disponibili diversi schemi di apprendimento, può essere vantaggioso non scegliere il risultato ottimale per il tuo set di dati (utilizzando la convalida incrociata), ma utilizzare tutti e combinare i risultati. Infine, il modo standard e ovvio di modellare una situazione di apprendimento multiclass come una classe a due classi può essere migliorata utilizzando una tecnica semplice ma sottile.


  Molti di questi risultati sono contraddittori, almeno in un primo momento. Come può essere una buona idea utilizzare insieme diversi modelli? Come puoi fare meglio che scegliere il modello che esegue meglio? Sicuramente tutto questo è in contrasto con il rasoio di Occam, che promuove la semplicità. Come puoi ottenere prestazioni di prima classe combinando modelli indifferenti, come sembra una di queste tecniche? Ma considerate comitati di persone, che spesso presentano decisioni più saggi di esperti individuali. Ricordiamo l'opinione di Epicurus che, di fronte a spiegazioni alternative, dovremmo conservarle tutte. Immagina un gruppo di specialisti ognuno dei quali eccelle in un dominio limitato anche se nessuno è competente in tutto il board. Nel lottare per capire come funzionano questi metodi, i ricercatori hanno esposto tutti i tipi di connessioni e collegamenti che hanno portato a miglioramenti ancora maggiori.

   Un altro fatto straordinario è che la prestazione di classificazione può spesso essere migliorata con l'aggiunta di una notevole quantità di dati che non sono contrassegnati, in altre parole i valori di classe sono sconosciuti. Ancora una volta, questo sembra volare direttamente davanti al buon senso, piuttosto come un fiume che scorre in salita o una macchina di movimento perpetua. Ma se fosse vero - ed è come mostreremo nella sezione 7.6 - avrebbe grande importanza pratica perché esistono molte situazioni in cui i dati etichettati sono scarsi ma i dati non etichettati sono abbondanti. Leggete su e preparatevi ad essere sorpresi.
  Attribute selection

  La maggior parte degli algoritmi di apprendimento macchina sono progettati per imparare quali sono gli attributi più appropriati da utilizzare per prendere le loro decisioni. Ad esempio, i metodi decision tree scelgono l'attributo più promettente per dividersi in ogni punto e dovrebbero - in teoria - non selezionare mai gli attributi irrilevanti o inutili. Avere più caratteristiche dovrebbe sicuramente - in teoria - portare a un potere più discriminante, mai meno. "Qual è la differenza tra teoria e pratica?" Chiede una vecchia domanda. "Non c'è differenza", risponde la risposta, "nella teoria. Ma in pratica esiste. "Anche qui esiste: in pratica, l'aggiunta di attributi irrilevanti o distruttivi a un set di dati spesso" confonde "i sistemi di apprendimento delle macchine.


  Gli esperimenti con un utente di alberi decisionali (C4.5) hanno dimostrato che l'aggiunta a set di dati standard di un attributo binario casuale generato gettando una moneta imparziale influenza la prestazione di classificazione, causandone un deterioramento (tipicamente dal 5 al 10% nelle situazioni testate). Ciò accade perché a un certo punto negli alberi che vengono appresi, l'attributo irrilevante viene sempre scelto per raggrupparsi, causando errori casuali quando vengono elaborati i dati del test. Come può essere questo, quando i discenti degli alberi decisionali sono abilmente progettati per scegliere l'attributo migliore per la suddivisione in ogni nodo? La ragione è sottile. Mentre procedi più in basso nell'albero, sempre meno dati sono disponibili per aiutare a prendere la decisione di selezione. A un certo punto, con pochi dati, l'attributo casuale "sembrerà buono" solo per caso. Poiché il numero di nodi a ogni livello aumenta in modo esponenziale con la profondità, la probabilità dell'attributo rogue sembra buona da qualche parte lungo la "frontiera moltiplica" quando l'albero si approfondisce. Il vero problema è che si raggiunge inevitabilmente profondità in cui solo una piccola quantità di dati è disponibile per la selezione degli attributi. Se il set di dati fosse più grande, non avrebbe necessariamente aiutato, probabilmente andresti più in profondità.


  Gli studenti di "alberi divide-and-conquer" e di "regole separate-and-conquer" soffrono di questo effetto perché inesorabilmente riducono la quantità di dati su cui basano giudizi. Gli studenti basati su istanze sono molto sensibili a attributi irrilevanti perché lavorano sempre nei quartieri locali, prendendo in considerazione solo poche istruzioni di formazione per ogni decisione. Infatti, è stato dimostrato che il numero di istanze di formazione necessarie per produrre un livello di prestazione predeterminato per l'apprendimento basato su istanze aumenta in modo esponenziale con il numero di attributi irrilevanti presenti. Naïve Bayes, invece, non frammenta lo spazio di istanza e ignora fortemente gli attributi irrilevanti. Presuppone con la progettazione che tutti gli attributi sono indipendenti l'uno dall'altro, un presupposto che è giusto per gli attributi "distracter" casuali. Ma attraverso questa stessa ipotesi, Naïve Bayes paga un prezzo pesante in altri modi perché il suo funzionamento è danneggiato con l'aggiunta di attributi ridondanti.

    Il fatto che i distrattori irrilevanti degradino le prestazioni degli alberi decisionali "state-of-the-art" e degli studenti di regola è, in un primo momento, sorprendente. Ancora più sorprendente è che gli attributi rilevanti possono anche essere dannosi. Ad esempio, supponiamo che in un set di dati a due classi un nuovo attributo venisse aggiunto che abbia lo stesso valore della classe da prevedere la maggior parte del tempo (65%) e il valore opposto il resto del tempo distribuito in modo casuale tra le istanze . Gli esperimenti con i set di dati standard hanno dimostrato che ciò può causare la deteriorazione della precisione di classificazione (da 1% a 5% nelle situazioni testate). Il problema è che il nuovo attributo è (naturalmente) scelto per dividere in alto l'albero. Ciò ha l'effetto di frammentare l'insieme di istanze disponibili nei nodi sottostanti in modo che altre scelte siano basate su dati più sparsi.

 A causa dell'effetto negativo di attributi irrilevanti sulla maggior parte dei sistemi di apprendimento in macchina, è comune precedere l'apprendimento con una fase di selezione degli attributi che cerca di eliminare tutti gli attributi ma gli attributi più rilevanti. Il modo migliore per selezionare gli attributi rilevanti è manualmente, basato su una profonda comprensione del problema dell'apprendimento e di ciò che gli attributi significano. Tuttavia, i metodi automatici possono anche essere utili. Ridurre la dimensionalità dei dati eliminando gli attributi non idonei migliora le prestazioni degli algoritmi di apprendimento. Inoltre li velocizza, anche se questo può essere sovrapposto al calcolo della selezione degli attributi. Ancora più importante, la riduzione della dimensione riduce una rappresentazione più compatta e più facilmente interpretabile del concetto di destinazione, mettendo a fuoco l'attenzione dell'utente sulle variabili più rilevanti.
  Scheme-independent selection

Quando si seleziona un buon sottoinsieme di attributi, ci sono due approcci fondamentalmente diversi. Uno è fare una valutazione indipendente basata sulle caratteristiche generali dei dati; L'altro è quello di valutare il sottoinsieme utilizzando l'algoritmo di apprendimento macchina che sarà finalmente utilizzato per l'apprendimento. Il primo è chiamato il metodo del filtro, perché il set di attributo viene filtrato per produrre il sottoinsieme più promettente prima che l'apprendimento inizi. Il secondo è il metodo del wrapper, perché l'algoritmo di apprendimento è avvolto nella procedura di selezione. Fare una valutazione indipendente di un sottoinsieme di attributi sarebbe facile se ci fosse un buon modo per determinare quando un attributo era rilevante per scegliere la classe. Tuttavia, non esiste una misura di "rilevanza" universalmente accettata, sebbene né siano stati proposti diversi.

   Un semplice metodo indipendente dal sistema di selezione degli attributi è quello di utilizzare abbastanza attributi sufficienti per dividere lo spazio di istanza in modo tale da separare tutte le istanze di formazione. Ad esempio, se vengono utilizzati solo uno o due attributi, ci saranno generalmente più istanze che hanno la stessa combinazione di valori di attributo. All'altro estremo, l'insieme completo di attributi probabilmente distingue le istanze in modo univoco in modo che nessuna due istanze abbiano gli stessi valori per tutti gli attributi. (Questo non sarà necessariamente il caso, tuttavia, i set di dati contengono talvolta istanze con gli stessi valori di attributo, ma classi diverse). È molto intuitivo selezionare il più piccolo sottoinsieme di attributi che distingue in modo univoco tutti i casi. Ciò può essere facilmente trovato utilizzando una ricerca esaustiva, anche se a considerevoli spese di calcolo. Purtroppo, questa forte prevenzione verso la coerenza dell'attributo impostato sui dati di addestramento è statisticamente ingiustificata e può portare ad overfitting: l'algoritmo può andare a lunghezze inutili per riparare un'inconsistenza che è stata in effetti semplicemente causata dal rumore.

  Gli algoritmi di apprendimento delle macchine possono essere utilizzati per la selezione degli attributi. Ad esempio, è possibile applicare un algoritmo dell'albero di decisione all'insieme completo di dati e quindi selezionare solo gli attributi effettivamente utilizzati nell'albero. Anche se questa selezione non avrebbe alcun effetto se la seconda fase ha semplicemente costruito un altro albero, avrà un effetto su un diverso algoritmo di apprendimento. Ad esempio, l'algoritmo di prossimità più vicino è notoriamente suscettibile di attributi irrilevanti e la sua prestazione può essere migliorata utilizzando un costruttore di decisioni come filtro per la selezione degli attributi in primo luogo. Il metodo di prossimità più vicino può risultare anche migliore dell'algoritmo dell'albero di decisione utilizzato per il filtraggio. Come un altro esempio, il semplice schema 1R descritto nel Capitolo 4 è stato utilizzato per selezionare gli attributi di un utente di albero di decisione valutando l'effetto della ramificazione su diversi attributi (anche se un metodo basato su errori come 1R non può essere la scelta ottimale per Come vedremo più avanti quando si copre il problema relativo della discretizzazione supervisionata). Spesso l'albero decisionale esegue altrettanto bene quando solo i due o tre attributi principali vengono utilizzati per la sua costruzione - ed è molto più facile da capire. In questo approccio, l'utente determina quanti attributi utilizzare per costruire l'albero decisionale.

   Un'altra possibilità è quella di utilizzare un algoritmo che costruisca un modello lineare - ad esempio una macchina vettoriale lineare di supporto - e classifica gli attributi in base alla dimensione dei coefficienti. Una variante più sofisticata applica l'algoritmo di apprendimento ripetutamente. Costruisce un modello, classifica gli attributi basati sui coefficienti, elimina il rango più alto e ripete il processo finché non vengono rimossi tutti gli attributi. Questo metodo di eliminazione delle funzioni ricorsive è stato trovato per produrre risultati migliori su determinati set di dati (ad esempio, quando identificano importanti geni per la classificazione dei tumori) che semplicemente attributi di classifica basati su un singolo modello. Con entrambi i metodi è importante assicurarsi che gli attributi siano misurati sulla stessa scala; Altrimenti i coefficienti non sono comparabili. Si noti che queste tecniche solo producono una classifica; È necessario utilizzare un altro metodo per determinare il numero appropriato di attributi da utilizzare.

  Gli attributi possono essere selezionati anche utilizzando metodi di apprendimento basati su istanze. Potresti campionare istanze in modo casuale dal set di allenamento e controllare i record vicini delle stesse e diverse classi - "vicino a colpi" e "vicino a miss". Se un colpo vicino ha un valore diverso per un determinato attributo, tale attributo sembra irrilevante e Il suo peso dovrebbe essere diminuito. D'altra parte, se una mancanza di prossimità ha un valore diverso, l'attributo sembra essere rilevante e il suo peso dovrebbe essere aumentato. Naturalmente, questo è il tipo di procedura standard utilizzato per il ponderazione degli attributi per l'apprendimento basato su istanze, descritto nella sezione 6.4. Dopo aver ripetuto molte volte questa operazione, viene eseguita la selezione: vengono scelti solo gli attributi con pesi positivi. Come nella formulazione incrementale standard dell'apprendimento basata su istanze, diversi risultati verranno ottenuti ogni volta che il processo viene ripetuto, a causa del diverso ordinamento di esempi. Ciò può essere evitato utilizzando tutte le istruzioni di formazione e tenendo conto di tutti i colpi vicini e quasi mancanti di ciascuno.


   Uno svantaggio più grave è che il metodo non rileverà un attributo ridondante perché è correlato ad un altro attributo. Nel caso estremo, due attributi identici verrebbero trattati allo stesso modo, sia selezionati sia entrambi respinti. È stata suggerita una modifica che sembra andare in qualche modo per affrontare questo problema prendendo in considerazione i pesi attributi correnti per calcolare i colpi e le missioni più vicini. Un altro modo per eliminare gli attributi ridondanti e quelli irrilevanti è quello di selezionare un sottoinsieme di attributi che correlano individualmente con la classe ma hanno poca intercorrelazione. La correlazione tra due attributi nominali A e B può essere misurata usando l'incertezza simmetrica:


........


  dove H è la funzione di entropia descritta nella sezione 4.3. Le entropie si basano sulla probabilità associata ad ogni valore attributo; H (A, B), l'entropia congiunta di A e B, è calcolata dalle probabilità congiunte di tutte le combinazioni di valori di A e B. L'incertezza simmetrica è sempre tra 0 e 1. La selezione delle caratteristiche basate sulla correlazione determina la bontà Un insieme di attributi che utilizzano


  ............


  dove C è l'attributo di classe e gli indici i e j si trovano su tutti gli attributi dell'insieme. Se tutti gli attributi m nel sottogruppo si correlano perfettamente con la classe e gli uni con gli altri, il numeratore diventa m e il denominatore diventa m 2, che è anche m. Quindi, la misura è 1, che risulta essere il valore massimo che può raggiungere (il minimo è 0). Chiaramente questo non è ideale, perché vogliamo evitare attributi ridondanti. Tuttavia, qualsiasi sottoinsieme di questo set avrà anche valore 1. Quando si utilizza questo criterio per cercare un buon sottoinsieme di attributi, è opportuno interrompere i legami a favore del sottogruppo più piccolo.
   Searching the attribute space

La maggior parte dei metodi per la selezione degli attributi comporta la ricerca dello spazio degli attributi "per il sottoinsieme" che è più probabile per predire la classe migliore. La Figura 7.1 illustra lo spazio degli attributi per il dataset meteo - ora troppo "familiare". Il numero di sottoinsiemi di attributi possibili aumenta in modo esponenziale con il numero di attributi, rendendo la ricerca esaustiva per tutti, ma i problemi più semplici.

 Tipicamente, lo spazio viene ricercato avidamente in una delle due direzioni, dall'alto verso il basso o dal basso verso l'alto nella figura. Ad ogni fase, viene apportata una modifica locale al sottoinsieme di attributi corrente aggiungendo o eliminando un singolo attributo. La direzione verso il basso, in cui si inizia senza attributi e li aggiunge uno alla volta, viene chiamata in avanti selezione. L'alto, in cui si inizia con l'insieme completo e si elimina gli attributi uno alla volta, è l'eliminazione all'indietro. Nella selezione in avanti, ciascun attributo che non è già presente nel sottosistema corrente viene provocato ad esso e viene determinato il set di attributi risultante, ad esempio convalida incrociata come descritto nella sezione seguente. Questa valutazione produce una misura numerica delle prestazioni attese del sottoinsieme.

  L'effetto di aggiungere ogni attributo a sua volta è quantificato da questa misura, il migliore è scelto e la procedura continua. Tuttavia, se nessun attributo produce un miglioramento quando viene aggiunto al sottoinsieme corrente, la ricerca termina. Si tratta di una procedura di ricerca avida e garantita per trovare un insieme di attributi localmente ma non necessariamente globalmente ottimali. L'eliminazione all'indietro opera in modo completamente analogo. In entrambi i casi, una leggera bias viene spesso introdotta verso piccoli set di attributi. Ciò può essere fatto per la selezione in avanti insistendo che se la ricerca continua, la misura di valutazione non deve solo aumentare ma anche aumentare di almeno una piccola quantità predeterminata. Una simile modifica funziona per l'eliminazione all'indietro.

  Esistono metodi di ricerca più sofisticati. La selezione avanti e l'eliminazione all'indietro possono essere combinate in una ricerca bidirezionale; Ancora uno può cominciare con tutti gli attributi o con nessuno di loro. "La miglior prima ricerca" è un metodo che non si limita a terminare quando la prestazione inizia a scendere, ma mantiene un elenco di tutti i sottolivelli degli attributi valutati finora, ordinati in base alla misura di prestazioni, in modo che possa rivisitare una configurazione precedente. Dato sufficiente tempo esplorerà l'intero spazio, a meno che non sia impedito da qualche tipo di criterio di arresto. La ricerca del fascio è simile ma tronca la sua lista di sottoinsiemi di attributi in ogni fase in modo che contenga solo un numero fisso - la larghezza del fascio - dei candidati più promettenti. Le procedure di ricerca di algoritmi genetici sono basate sul principio della selezione naturale: esse "evolvono" i sottotitoli di una buona funzionalità utilizzando perturbazioni casuali di un elenco corrente di sottosezioni di candidati.
  Scheme-specific selection

  La prestazione di un sottoinsieme di attributi con 'selezione specifica del sistema' viene misurata in termini di prestazioni di classificazione dello schema di apprendimento utilizzando solo quegli attributi. Dato un sottoinsieme di attributi, la precisione viene stimata utilizzando la normale procedura di convalida incrociata descritta nella Sezione 5.3. Naturalmente, altri metodi di valutazione come le prestazioni su un set di holdout (sezione 5.3) o lo stimatore di bootstrap (sezione 5.4) potrebbero essere ugualmente ben utilizzati.
   L'intero processo di selezione degli attributi è di calcolo intensivo. Se ogni valutazione comporta una convalida incrociata di 10 volte, la procedura di apprendimento deve essere eseguita 10 volte. Con gli attributi k, la selezione in avanti euristica o l'eliminazione all'indietro moltiplicano il tempo di valutazione per un fattore fino a k2 e per le ricerche più sofisticate, la penalità sarà molto maggiore, fino a 2k per un algoritmo esaustivo che esamina ciascuno dei due sottotitoli possibili da 2k .    

  Buoni risultati sono stati dimostrati su molti set di dati. In termini generali, l'eliminazione all'indietro produce set di attributi maggiori e una migliore precisione di classificazione, rispetto alla selezione in avanti. La ragione è che la misura di prestazioni è solo una stima e una stima ottimistica stimola entrambe queste procedure di ricerca a fermare "eliminazione prematuramente-indietro" con troppi attributi e la selezione in avanti con insufficiente. Ma la selezione avanzata è utile se si pone l'accento sulla comprensione delle strutture decisionali coinvolte, poiché spesso riduce il numero di attributi con un effetto molto limitato sulla precisione della classificazione. L'esperienza sembra dimostrare che le tecniche di ricerca più sofisticate non sono generalmente giustificate, anche se in certi casi possono produrre risultati molto migliori.

  Un modo per accelerare il processo di ricerca è quello di smettere di valutare un sottoinsieme di attributi, non appena diventa evidente che è improbabile che ciò porti ad una precisione maggiore di un altro sottoinsieme di candidati. Questo è un lavoro per un test di significato statistico associato, eseguito tra il classificatore basato su questo sottoinsieme e tutti gli altri classificatori candidati basati su altri sottoinsiemi. La differenza di prestazioni tra due classificatori su una determinata istanza di prova può essere considerata -1, 0 o 1 a seconda che il primo classificatore sia peggiore, uguale o superiore alla seconda in quella istanza. T-test accoppiato (descritto nella sezione 5.5) può essere applicato a queste cifre sull'intero set di test, trattando efficacemente i risultati per ogni istanza come stima indipendente della differenza di prestazioni. Poi la convalida incrociata per un classificatore può essere terminata prematuramente non appena si scopre che è significativamente peggiore di un altro - cosa che naturalmente non può mai accadere. Potremmo voler scartare i classificatori in modo più aggressivo modificando il t-test per calcolare la probabilità che un classificatore sia migliore di un altro classificatore da almeno una piccola soglia specificata dall'utente. Se questa probabilità diventa molto piccola, possiamo scartare l'ex classificatore sulla base del fatto che è molto improbabile che si esegua sostanzialmente meglio di quest'ultimo.

  Questa metodologia si chiama ricerca di corsa e può essere implementata con diverse strategie di ricerca sottostanti. Quando viene utilizzato con la selezione in avanti, corriamo contemporaneamente tutte le eventuali aggiunte a un singolo attributo e rilasciamo quelle che non si eseguono abbastanza bene. Nell'eliminazione all'indietro, corriamo tutte le delezioni a un attributo. La ricerca di Schemata è un metodo più complicato appositamente progettato per la corsa; Gestisce una serie iterativa di razze che determinano ciascuno se un attributo particolare deve essere incluso. Gli altri attributi di questa gara sono inclusi o esclusi a caso in ogni punto della valutazione. Non appena una gara ha un vincitore chiaro, inizia la successiva iterazione delle gare, usando il vincitore come punto di partenza. Un'altra strategia di ricerca è quella di classificare gli attributi innanzitutto, utilizzando, ad esempio, il loro guadagno di informazioni (supponendo che siano discreti) e quindi correre la classifica. In questo caso la gara non include attributi, l'attributo top-ranking, i primi due attributi, i primi tre e così via.

  Qualunque sia il modo in cui lo fai, la selezione degli attributi specifici dello schema non consente in alcun modo un miglioramento uniforme delle prestazioni. A causa della complessità del processo, che è notevolmente aumentato dall'effetto di retroazione di includere un algoritmo di apprendimento della macchina target nel ciclo di selezione dell'attribuzione, è abbastanza difficile prevedere le condizioni in cui si rivelerà utile. Come in molte situazioni di "apprendimento macchina", "prova ed errore" usando la propria particolare fonte di dati è l'arbitro finale.

   C'è un tipo di classificatore per cui la selezione degli attributi specifici per lo schema è una parte essenziale del processo di apprendimento: la tabella di decisione. Come indicato nella sezione 3.1, l'intero problema delle tabelle di decisione di apprendimento consiste nella selezione degli attributi giusti da includere. Di solito questo viene fatto misurando la prestazione della configurazione della tabella per i sottoinsiemi degli attributi e scegliendo il sottoinsieme più performante. Fortunatamente, la convalida incrociata di una sola uscita è molto conveniente per questo tipo di classificatore. Ottenere l'errore cross-validation da una tabella di decisione derivata dai dati di addestramento è solo una questione di manipolazione dei conteggi delle classi associati a ciascuna delle voci della tabella, in quanto la struttura della tabella non cambia quando le istanze vengono aggiunte o eliminate. Lo spazio dell'attributo viene generalmente ricercato dalla ricerca di prima scelta, poiché questa strategia è meno probabile che si blocchi ad un massimo locale rispetto ad altri, ad esempio la selezione in avanti.

  Concludiamo la nostra discussione con una storia di successo. Un metodo di apprendimento per il quale un approccio di selezione degli attributi specifici per schemi ha mostrato buoni risultati è Naïve Bayes. Anche se questo metodo si occupa molto di attributi casuali, ha il potenziale per essere falsato quando ci sono dipendenze tra gli attributi e soprattutto quando vengono aggiunti quelli ridondanti. Tuttavia, sono stati riportati buoni risultati utilizzando l'algoritmo di selezione in avanti - più in grado di rilevare quando si aggiunge un attributo ridondante rispetto all'approccio di eliminazione all'indietro - in combinazione con una metrica molto semplice e quasi "ingenua" che determina la La qualità di un sottoinsieme di attributi per essere semplicemente la performance dell'algoritmo appreso sul set di formazione. Come è stato sottolineato nel Capitolo 5, le prestazioni di allenamento non sono certamente un indicatore affidabile delle prestazioni test-set. Tuttavia, gli esperimenti mostrano che questa semplice modifica a Naïve Bayes migliora notevolmente la sua performance su quei set di dati standard per i quali non si comporta bene come classificatori a base di alberi o regole e non ha alcun effetto negativo sui risultati sui set di dati su cui Naïve Bayes già fa bene. Bayes selettivo Naïve, come viene chiamato questo metodo di apprendimento, è una tecnica di apprendimento abile che esegue in modo affidabile e 'ben in pratica'.
  Discretizing numeric attributes

  Alcuni algoritmi di classificazione e raggruppamento si occupano solo di attributi nominali e non possono gestire quelli misurati su una scala numerica. Per utilizzarli su set di dati generali, gli attributi numerici devono prima essere "discretizzati" in un piccolo numero di gamme distinte. Anche gli algoritmi di apprendimento che gestiscono gli attributi numerici talvolta li trattano in modi che non sono del tutto soddisfacenti. I metodi statistici di cluster spesso assumono che gli attributi numerici hanno una distribuzione normale - spesso non un assunto molto plausibile nella pratica - e l'estensione standard del classificatore Naïve Bayes per gestire gli attributi numerici adotta la stessa ipotesi. Anche se la maggior parte degli alunni di decisione e degli studenti decision rule possono gestire gli attributi numerici, alcune implementazioni funzionano molto più lentamente quando gli attributi numerici sono presenti perché ordinano ripetutamente i valori degli attributi. Per tutte queste ragioni si pone la domanda: quale è un buon modo per discretizzare gli attributi numerici in intervalli prima di ogni apprendimento?

  Abbiamo già incontrato alcuni metodi per discretizzare gli attributi numerici. Lo schema di apprendimento 1R descritto nel Capitolo 4 utilizza una tecnica semplice ma efficace: ordinare le istanze dal valore dell'attributo e assegnare il valore a intervalli nei punti che cambia il valore della classe, ad eccezione di un certo numero minimo di istanze nella classe di maggioranza Sei) deve trovarsi in ognuna delle gamme, il che significa che ogni gamma può includere una miscela di valori di classe. Questo è un metodo di "discrezionalizzazione" globale che viene applicato a tutti gli attributi continui prima dell'inizio dell'apprendimento.

  I discenti del "albero decisionale", d'altra parte, trattano gli attributi numerici a livello locale, esaminando gli attributi ad ogni nodo dell'albero quando viene costruito per vedere se valgono degradandosi e solo a quel punto decidere sul Il posto migliore per dividere attributi continui. Anche se il metodo di costruzione dell'albero che abbiamo esaminato nel capitolo 6 considera solo le divisioni binarie di attributi continui, si può immaginare una discretizzazione completa che si svolge a quel punto, dando una divisione multipla su un attributo numerico. I pro ei contro dell'approccio locale e globale sono chiari. La discretizzazione locale è adattata al contesto reale fornito da ciascun nodo ad albero e produrrà discrezioni diverse dello stesso attributo in luoghi diversi dell'albero se ciò sembra opportuno. Tuttavia, le sue decisioni si basano su meno dati come aumenta la profondità dell'albero, il che compromette la loro affidabilità. Se gli alberi vengono sviluppati per uscire a foglie di singolo istanza prima di essere rimosse, come nella tecnica normale di potatura indietro, è chiaro che molte decisioni di discrezionalità saranno basate su dati grossolanamente inadeguati.

  Quando si utilizza la discretizzazione globale prima di applicare un metodo di apprendimento, ci sono due modi possibili per presentare i dati discretizzati al discente. Il più ovvio è trattare attributi discretizzati come quelli nominali: ogni intervallo di discretizzazione è rappresentato da un valore dell'attributo nominale. Tuttavia, poiché un attributo discretizzato deriva da un numero numerico, i suoi valori vengono ordinati e trattandolo come nomina scarta queste informazioni di ordinazione potenzialmente preziose. Naturalmente, se uno schema di apprendimento può gestire direttamente gli attributi ordinati, la soluzione è ovvia: ogni attributo discretizzato viene dichiarato di tipo "ordinato".
    Se il metodo di apprendimento non è in grado di gestire gli attributi ordinati, esiste ancora un modo semplice per consentirlo di sfruttare le informazioni di ordinazione: trasformare ogni attributo discretizzato in un insieme di attributi binari prima che venga applicato lo schema di apprendimento. Supponendo che l'attributo discretizzato abbia valori k, viene trasformato in attributi binari k-1, i cui i - 1 sono impostati su false ogni volta che il valore ith dell'attributo discretizzato è presente nei dati e altrimenti vero.
   Gli attributi restanti sono impostati su false. In altre parole, l'attributo binario (i - 1) indica se l'attributo discretizzato è minore di i. Se un allievo degli alberi decisionali divide su questo attributo, utilizza implicitamente le informazioni di ordinazione che codifica. Si noti che questa trasformazione è indipendente dal particolare metodo di discretizzazione applicato: è semplicemente un modo per codificare un attributo ordinato utilizzando un insieme di attributi binari.
  Unsupervised discretization

  Ci sono due approcci fondamentali al problema della discretizzazione. Uno è quello di quantizzare ciascun attributo in assenza di qualsiasi conoscenza delle classi delle istanze nel set di formazione "cosiddetta" discretizzazione non supervisionata. L'altro è quello di prendere in considerazione le classi quando si discretizza la discretizzazione-supervisione. Il primo è l'unica possibilità quando si tratta di problemi di clustering in cui le classi sono sconosciute o inesistenti.
L'ovvio modo di discretizzare un attributo numerico è quello di dividere la propria gamma in un numero prestabilito di intervalli uguali: un punto fisso fisso e indipendente dal dato. Questo viene spesso fatto al momento della raccolta dei dati. Ma, come qualsiasi metodo di discretizzazione non supervisionato, esegue il rischio di distruggere le distinzioni che si sarebbero dimostrate utili nel processo di apprendimento utilizzando gradazioni troppo grossolane o da scelte sfortunate di confine che inutilmente si riuniscono molti casi di classi diverse.

  Il binning di uguale intervallo spesso distribuisce istanze molto in modo non uniforme: alcuni contenitori contengono molti istanze e altri non contengono nessuno. Questo può compromettere seriamente la capacità dell'attributo di contribuire a costruire buone strutture decisionali. Spesso è meglio permettere che gli intervalli siano di diversa grandezza, scegliendoli in modo che gli stessi esempi di formazione rientrino in ciascuno di essi. Questo metodo, la frequenza di equalizzazione, divide l'intervallo dell'attributo in un numero predefinito di cestini basati sulla distribuzione di esempi lungo quell'asse - talvolta chiamata equalizzazione dell'istogramma, poiché se si esegue un istogramma del contenuto dei cestini risultanti, esso sarà completamente piatto. Se si visualizza il numero di scomparti come risorsa, questo metodo lo utilizza al meglio.

  Tuttavia, la binning di frequenza a pari frequenza è ancora sconosciuta alle classi di istanze e questo può causare conflitti difettosi. Ad esempio, se tutte le istanze in un contenitore hanno una classe e tutte le istanze del prossimo bin di livello superiore hanno un altro tranne il primo, che ha la classe originale, è certamente opportuno rispettare le divisioni di classe e includere quella prima istanza nel Cestino precedente, sacrificando la proprietà a frequenza uguale per l'omogeneità. La discretizzazione supervisionata - tenendo conto delle classi durante il processo - ha sicuramente vantaggi.
Tuttavia, si è scoperto che il binning di frequenza a pari frequenza può dare ottimi risultati, almeno in combinazione con lo schema di apprendimento Naïve Bayes, quando il numero di scomparti viene scelto in modo dipendente dai dati impostandolo alla radice quadrata del numero Di casi. Questo metodo si chiama discretizzazione proporzionale a k-interval.
  Entropy-based discretization

Poiché il criterio utilizzato per la suddivisione di un attributo numerico durante la formazione di un albero di decisione funziona bene in pratica, sembra una buona idea estenderla ad una discretizzazione più generale dividendo ricorrendo intervalli fino a quando non è il momento di interrompere. Nel capitolo 6 abbiamo visto come ordinare le istanze dal valore dell'attributo e considerare, per ogni punto di splitting possibile, il guadagno informativo della divisione risultante. Per discretizzare l'attributo, una volta determinata la prima divisione, il processo di suddivisione può essere ripetuto nelle parti superiori e basse dell'intervallo, e così via, in modo ricorsivo.
Per vedere che ciò funziona in pratica, rivediamo l'esempio a pagina 189 per discretizzare l'attributo di temperatura dei dati meteo, i cui valori sono  

  .......

(I valori ripetuti sono stati collassati insieme.) Il guadagno di informazioni per ciascuna delle 11 posizioni possibili per il punto di interruzione è calcolato nel modo consueto. Ad esempio, il valore dell'informazione della temperatura di prova <71,5, che divide l'intervallo in quattro sì e due no per cinque sì e tre no, è


info([4, 2], [5, 3]) = (6 14) * info([4, 2]) + (8 14) * info([5, 3]) = 0.939 bits


Questo rappresenta la quantità di informazioni necessarie per specificare i singoli valori di sì e non dato la suddivisione. Cerchiamo una discretizzazione che rende i sottointervalli più pura possibile; Di conseguenza, scegliamo di dividere nel punto in cui il valore dell'informazione è più piccolo. (Questo è lo stesso della suddivisione in cui il guadagno di informazioni, definito come la differenza tra il valore dell'informazione senza la suddivisione e quello con la divisione, è più grande.) Come prima, mettiamo le soglie numeriche a metà tra i valori che delimitano i limiti di un concetto.


Figure 7.3 The result of discretizing the temperature attribute.





  Il grafico con l'etichetta A in Figura 7.2 mostra i valori di informazioni in ogni punto di taglio possibile in questa prima fase. La divisione più pulita - il più piccolo valore d'informazione - è a una temperatura di 84 (0,827 bit), che separa solo il valore finale, senza alcun caso, dall'elenco precedente. Le classi di istanza sono scritte sotto l'asse orizzontale per facilitare l'interpretazione. L'invocazione dell'algoritmo nell'intervallo inferiore delle temperature, da 64 a 83, produce il grafico con l'etichetta B. Questo ha un minimo a 80.5 (0.800 bit), che divide i due valori successivi, entrambi i casi di sì. Ricorrendo ancora all'algoritmo nell'intervallo più basso, ora da 64 a 80, viene generato il grafico con l'etichetta C (indicata punteggiata per distinguerla dagli altri). Il minimo è a 77.5 (0.801 bit), dividendo un'altra no instance. Il grafico D ha un minimo di 73,5 (0,764 bit), dividendo due istanze di sì. Il grafico E (nuovamente tratteggiato, puramente per renderlo più facilmente visibile), per l'intervallo di temperatura da 64 a 72, ha un minimo di 70,5 (0,796 bit), che divide due nodi e un sì. Infine, il grafico F, per l'intervallo da 64 a 70, ha un minimo di 66,5 (0,4 bit).

  La discretizzazione finale dell'attributo di temperatura è mostrata in Figura 7.3. Il fatto che la ricorsione si verifica solo nel primo intervallo di ciascuna divisione è un artefatto di questo esempio: in generale, sia gli intervalli superiori che quelli più bassi dovranno essere ulteriormente divisi. Sotto ogni divisione è l'etichetta del grafico della Figura 7.2 che è responsabile per esso, e sotto questo è il valore effettivo del punto di divisione.

  Può essere dimostrato teoricamente che un punto di taglio che minimizza il valore dell'informazione non si verificherà mai tra due istanze della stessa classe. Ciò porta ad una ottima ottimizzazione: bisogna solo considerare potenziali divisioni che separano istanze di classi diverse. Si noti che se le etichette di classe sono state assegnate agli intervalli basati sulla classe di maggioranza nell'intervallo, non ci sarebbe alcuna garanzia che gli intervalli adiacenti ricevessero diverse etichette. Potrebbe essere tentato di considerare gli intervalli di fusione con la stessa classe di maggioranza (ad esempio, i primi due intervalli di Figura 7.3), ma come vedremo più avanti (pagine 302-304) non è una cosa buona da fare in generale.

  L'unico problema da considerare è il criterio di arresto. Nell'esempio di temperatura, la maggior parte degli intervalli identificati erano "pura" in quanto tutti i loro casi hanno la stessa classe e non c'è chiaramente alcun punto nel tentativo di dividere tale intervallo. (Le eccezioni erano l'intervallo finale, che abbiamo tacitamente deciso di non dividere e l'intervallo da 70,5 a 73,5). In generale, tuttavia, le cose non sono così semplici.

   Un buon modo per fermare la procedura di discretizzazione della divisione basato su entropia risulta essere il principio MDL che abbiamo incontrato nel Capitolo 5. In conformità a questo principio, vogliamo ridurre al minimo la dimensione della "teoria" più la dimensione delle informazioni necessarie Per specificare tutti i dati forniti dalla teoria. In questo caso, se si divide, la "teoria" è il punto di divisione e stiamo confrontando la situazione in cui si divide con quello in cui non lo facciamo. In entrambi i casi supponiamo che le istanze siano note, ma le loro etichette di classe non lo sono. Se non dividiamo, le classi possono essere trasmesse codificando l'etichetta di ogni istanza. Se lo facciamo, codiciamo prima il punto di divisione (in log2 [N-1] bit, dove N è il numero di istanze), quindi le classi delle istanze sotto quel punto e poi le classi di quelle sopra. Potete immaginare che se la divisione è una buona cosa - diciamo, tutte le classi che seguono sono sì e tutte quelle che sopra non sono - allora c'è molto da guadagnare dividendo. Se esiste un numero uguale di istanze sì e no, ogni istanza costa 1 bit senza divisione, ma non più di 0 bit con la suddivisione: non è proprio 0 poiché i valori della classe associati alla suddivisione devono essere codificati, ma questa penalità è Ammortizzato in tutti i casi. In questo caso, se ci sono molti esempi, la pena di dover codificare il punto di divisione sarà ben oltrepassata dalle informazioni salvate dalla suddivisione.

  Abbiamo sottolineato nella sezione 5.9 che quando applica il principio MDL, il diavolo è nei dettagli. Nel caso relativamente semplice della discretizzazione, la situazione è tractable anche se non semplice. Le quantità di informazioni possono essere ottenute esattamente sotto alcune ipotesi ragionevoli. Non andiamo nei dettagli, ma il risultato è che la ripartizione dettata da un particolare punto di taglio è valsa la pena, mentre se la gain di informazioni per quella divisione supera un certo valore che dipende dal numero di istanze N, il numero di classi k , L'entropia degli istanze E, l'entropia delle istanze in ciascun sottointervallo E1 e E2 e il numero di classi rappresentate in ciascun sottointervallo k1 e k2:

.........



 Il primo componente è l'informazione necessaria per specificare il punto di suddivisione; La seconda è una correzione dovuta alla necessità di trasmettere quali classi corrispondono ai subintervalli superiori e inferiori.
    Quando applicato all'esempio di temperatura, questo criterio impedisce qualsiasi condivisione. La prima divisione rimuove solo l'esempio finale e, come si può immaginare, pochissime informazioni reali si guadagnano quando trasmettono le classi - in realtà, il criterio MDL non creerà mai un intervallo che contenga solo un esempio. La mancata discretizzazione della temperatura impedisce effettivamente di svolgere alcun ruolo nella struttura decisionale finale poiché lo stesso valore discreto sarà dato a tutte le istanze. In questa situazione, questo è perfettamente appropriato: l'attributo di temperatura non si verifica nei buoni alberi decisionali o nelle regole per i dati meteorologici. In effetti, la mancata discrezione equivale a attribuire la selezione.
    Other discretization methods

  Il metodo basato su entropia con il criterio di arresto MDL è una delle migliori tecniche generali per la discretizzazione controllata. Tuttavia, molti altri metodi sono stati studiati. Ad esempio, invece di procedere dall'alto verso il basso per intervalli di suddivisione ricorsiva fino a quando non si soddisfi un certo criterio di arresto, è possibile lavorare in basso, prima di immettere ciascuna istanza nel proprio intervallo e di considerare se si possono fondere intervalli adiacenti. Puoi applicare un criterio statistico per vedere quali sarebbero i due migliori intervalli da unire e unirli se la statistica supera un certo livello di confidenza preimpostato, ripetendo l'operazione fino a quando non si verifica un potenziale di fusione. Il test c2 è adatto ed è stato utilizzato per questo scopo. Invece di specificare una soglia di significatività preimpostata, sono disponibili tecniche più complesse per determinare automaticamente un livello appropriato.

   Un approccio piuttosto diverso è quello di contare il numero di errori che una discretizzazione fa quando prevede la classe di ogni istruzione, supponendo che ogni intervallo riceve la classe di maggioranza. Ad esempio, il metodo 1R descritto in precedenza è basato su errori: si concentra sugli errori piuttosto che sull'entropia. Tuttavia, la migliore discretizzazione possibile in termini di conteggio degli errori si ottiene utilizzando il maggior numero possibile di intervalli e questo caso degenerato dovrebbe essere evitato limitando il numero di intervalli in anticipo. Ad esempio, si potrebbe chiedere quale sia il modo migliore per discretizzare un attributo in intervalli k in modo da ridurre al minimo il numero di errori?

 Il metodo 'brute-force' per trovare il modo migliore di partizionare un attributo in intervalli k in modo da minimizzare il conteggio degli errori è esponenziale in k e quindi impossibile. Tuttavia, ci sono sistemi molto più efficienti che si basano sull'idea di programmazione dinamica. La programmazione dinamica si applica non solo alla misura di conteggio degli errori ma anche a qualsiasi funzione di impurità addizionali e può trovare la suddivisione delle istanze N in intervalli di k in modo da minimizzare l'impurità nel tempo proporzionale a kN 2. Ciò dà un modo di Trovando la migliore discretizzazione basata su entropia, dando un potenziale miglioramento della qualità della discretizzazione (ma in pratica trascurabile) sul metodo ricostruttivo basato su entropia descritto in precedenza. La notizia per la discretizzazione basata sugli errori è ancora migliore, perché esiste un metodo che minimizza il conteggio degli errori nel tempo lineare in N.
   Entropy-based versus error-based discretization

Figure 7.4 Class distribution for a two-class, two-attribute problem.Perché non utilizzare la discretizzazione basata sugli errori, in quanto la discretizzazione ottimale può essere trovata molto rapidamente? La risposta è che c'è un grave inconveniente alla discretizzazione basata sugli errori: non può produrre intervalli adiacenti con la stessa etichetta (come i primi due della Figura 7.3). La ragione è che la fusione di due intervalli non influenzerà il conteggio degli errori ma libererà un intervallo che può essere utilizzato altrimenti dove ridurre il conteggio degli errori.

     Perché qualcuno vuole generare intervalli adiacenti con la stessa etichetta? Il motivo è meglio illustrato con un esempio. La Figura 7.4 mostra lo spazio di istanza per un semplice problema a due classi con due attributi numerici che vanno da 0 a 1. Le istanze appartengono a una classe (i punti) se il loro primo attributo (a1) è inferiore a 0,3 oppure se è inferiore a 0,7 E il loro secondo attributo (a2) è inferiore a 0,5. Altrimenti, appartengono all'altra classe (triangoli). I dati della Figura 7.4 sono stati generati artificialmente in base a questa regola.


  Ora supponiamo che stiamo cercando di discretizzare entrambi gli attributi in modo da apprendere le classi dagli attributi discretizzati. La migliore discretizzazione divide a1 in tre intervalli (da 0 a 0.3, da 0.3 a 0.7 e da 0.7 a 1.0) e da a2 in due intervalli (da 0 a 0.5 e da 0.5 a 1.0). Tenendo conto di questi attributi nominali, sarà facile imparare a distinguere le classi a parte con un semplice albero di decisione o un algoritmo di regole. Discretizzare a2 non è un problema. Per a1, tuttavia, i primi e gli ultimi intervalli avranno etichette opposte (puntino e triangolo rispettivamente).
  Il secondo avrà qualunque etichetta che si verifica nella maggior parte delle regioni da 0,3 a 0,7 (infatti è dotato dei dati riportati in Figura 7.4). In entrambi i casi, questa etichetta deve inevitabilmente essere la stessa di una delle etichette adiacenti, ovviamente ciò è vero qualunque sia la probabilità di classe che si verifica nella regione media. Quindi questa discretizzazione non sarà raggiunta con alcun metodo che minimizzi i conteggi di errore, perché un tale metodo non può produrre intervalli adiacenti con la stessa etichetta. Il punto è che ciò che cambia poiché il valore di a1 attraversa il limite a 0.3 non è la classe di maggioranza, ma la distribuzione di classi. La classe di maggioranza resta dot. La distribuzione, tuttavia, cambia notevolmente, dal 100% prima del confine fino a poco più del 50% dopo. E la distribuzione si ripresenta mentre il limite a 0,7 è attraversato, dal 50% allo 0%. I metodi di discretizzazione basati sull'entropia sono sensibili ai cambiamenti nella distribuzione anche se la classe di maggioranza non cambia. I metodi basati su errori non lo sono.
    Converting discrete to numeric attributes

  C'è un problema converso alla discretizzazione. Alcuni algoritmi di apprendimento, in particolare il metodo basato sull'istanza più vicina e le tecniche di previsione numerica che comportano la regressione, gestiscono naturalmente solo gli attributi numerici. Come possono essere estesi a attributi nominali?

  Nell'apprendimento basato sullo stesso modo, come descritto nella sezione 4.7, gli attributi discreti possono essere trattati come numerici definendo la "distanza" tra due valori nominali uguali a 0 e tra due valori diversi da 1 a meno della I valori reali coinvolti. Invece di modificare la funzione di distanza, questo può essere ottenuto utilizzando una trasformazione di attributo: sostituire un attributo nominale valutato k con k attributi binari sintetici, uno per ogni valore che indica se l'attributo ha tale valore. Se gli attributi hanno un peso uguale, questo raggiunge lo stesso effetto sulla funzione di distanza. La distanza è insensibile ai valori degli attributi perché vengono codificate solo informazioni "stesse" o "diverse", non le sfumature di differenza che possono essere associate ai diversi valori possibili dell'attributo. Ulteriori distinzioni possono essere fatte se gli attributi hanno pesi che riflettono la loro importanza relativa.

  Se i valori dell'attributo possono essere ordinati, si creano ulteriori possibilità. Per un problema di previsione numerica, il valore della classe media corrispondente ad ogni valore di un attributo nominale può essere calcolato dalle istanze di addestramento e utilizzato per determinare un ordine che questa tecnica è stata introdotta per gli alberi di modello nella Sezione 6.5. (È difficile trovare un modo analogo di ordinare valori di attributo per un problema di classificazione.) Un attributo nominale ordinato può essere sostituito con un numero intero in modo ovvio, ma ciò implica non solo un ordine, ma anche una metrica sull'attributo valori. L'implicazione di una metrica può essere evitata creando attributi binari sintetici k-1 per un attributo nominale valore k, nel modo descritto a pagina 297. Questa codifica implica ancora un'ordinazione tra diversi valori dell'attributo - i valori adiacenti differiscono in giusto Uno degli attributi sintetici, mentre quelli distanti differiscono in molti - ma non implica una pari distanza tra i valori degli attributi.
   Some useful transformations

   'Resourceful data miners' dispongono di una casella degli strumenti piena di tecniche, come la discretizzazione, per la trasformazione dei dati. Come abbiamo sottolineato nella Sezione 2.4, l'attività di data mining non è mai stata una questione di semplice acquisizione di un set di dati e di applicare ad esso un algoritmo di apprendimento. Ogni problema è diverso. Devi pensare ai dati e a ciò che significa, ed esaminarla da diversi punti di vista - creativamente! - per giungere ad una prospettiva adeguata. La trasformazione in diversi modi può aiutarti ad iniziare.

   Non è necessario creare la propria casella degli strumenti implementando le tecniche. Ambienti complessi per l'estrazione dei dati, come quelli descritti nella parte II di questo libro, contengono una vasta gamma di strumenti appropriati per l'utilizzo. Non è necessariamente una comprensione dettagliata di come vengono implementati. Ciò che serve è capire cosa fanno gli strumenti e come possono essere applicati. Nella Parte II elenchiamo e descrivere brevemente tutte le trasformazioni del banco dati Weka Data Mining

  I dati spesso richiedono trasformazioni matematiche generali di un insieme di attributi. Potrebbe essere utile definire nuovi attributi applicando funzioni matematiche specifiche a quelle esistenti. Due attributi di data potrebbero essere sottratti per dare un terzo attributo che rappresenta l'età - un esempio di una trasformazione semantica guidata dal significato degli attributi originali. Altre trasformazioni potrebbero essere suggerite dalle proprietà note dell'algoritmo di apprendimento. Se si sospetta una relazione lineare che coinvolge due attributi A e B e l'algoritmo è in grado di dividere in asse parallelo (come la maggior parte degli alberi di decisione e degli studenti di regole), il rapporto A / B potrebbe essere definito come un nuovo attributo. Le trasformazioni non sono necessariamente matematiche ma possono implicare conoscenze del mondo come i giorni della settimana, le vacanze civiche oi numeri atomici chimici. Potrebbero essere espressi come operazioni in un foglio di calcolo o come funzioni implementate da programmi informatici arbitrari. Oppure è possibile ridurre diversi attributi nominali a concatenare i loro valori, generando un attributo singolo k1 ¥ k2 rispettivamente da attributi con valori k1 e k2. La discretizzazione converte un attributo numerico a quello nominale e abbiamo visto in precedenza come convertire anche nell'altra direzione.

  Come un altro tipo di trasformazione, è possibile applicare una procedura di clustering al set di dati e quindi definire un nuovo attributo il cui valore per un'istanza specifica è il cluster che lo contiene utilizzando un'etichetta arbitraria per i cluster. In alternativa, con il clustering probabilistico, è possibile aumentare ogni istanza con le probabilità di adesione per ogni cluster, inclusi molti nuovi attributi in quanto esistono cluster.

   A volte è utile aggiungere rumore ai dati, forse per testare la robustezza di un algoritmo di apprendimento. Per assumere un attributo nominale e modificare una determinata percentuale dei suoi valori. Per ignorare i dati rinominando la relazione, i nomi degli attributi ei valori degli attributi nominali e delle stringhe - perché è spesso necessario anonimizzare i set di dati sensibili. Per casualizzare l'ordine di istanze o generare un campione casuale del set di dati reamblierizzandolo. Per ridurre un set di dati rimuovendo una determinata percentuale di istanze o tutte le istanze che dispongono di determinati valori per attributi nominali o valori numerici al di sopra o al di sotto di una determinata soglia. Oppure per rimuovere gli outlier applicando un metodo di classificazione al set di dati e eliminando istanze non classificate.

  Diversi tipi di richieste di input per le proprie trasformazioni. Se è possibile immettere file di dati sparse (vedere la sezione 2.4), potrebbe essere necessario essere in grado di convertire i set di dati in un modulo nonsparse e viceversa. L'input di testo e l'immissione di una serie temporale richiedono le proprie conversioni specializzate, descritte nelle sottosezioni che seguono. Ma innanzitutto esaminiamo due tecniche generali per trasformare i dati con attributi numerici in una forma di dimensione inferiore che può essere più utile per l'estrazione dei dati.
  Principal components analysis

 In un set di dati con attributi numerici k, è possibile visualizzare i dati come una nuvola di punti nello spazio k-dimensionale: le stelle del cielo, uno sciame di mosche congelato nel tempo, una trama bidimensionale di dispersione su carta. Gli attributi rappresentano le coordinate dello spazio. Ma gli assi utilizzati, il sistema di coordinate in sé, sono arbitrari. È possibile posizionare gli assi orizzontali e verticali sulla carta e rappresentare i punti della trama di dispersione usando queste coordinate oppure si potrebbe disegnare una linea retta arbitraria per rappresentare l'asse X e una perpendicolare al suo rappresentare Y. Per registrare le posizioni di Le mosche si possono utilizzare un sistema di coordinate convenzionali con un asse nord-sud, un asse est-ovest e un asse di salita. Ma altri sistemi di coordinate farebbero altrettanto bene. Le creature come le mosche non sanno a nord, a sud, ad est e ad ovest, sebbene, essendo soggette alla gravità, possono percepire come qualcosa di speciale. Per quanto riguarda le stelle del cielo, chi dice quale sia il sistema di coordinate "giusto"? Nel corso dei secoli i nostri antenati si sono mossi da una prospettiva geocentrica a quella eliocentrica a un puro relativismo, ogni turno di prospettiva è accompagnato da turbolenti sconvolgimenti religioso-scientifici e dolorosa esame del ruolo dell'umanità nell'universo di Dio.

  Torna al dataset. Proprio come in questi esempi, non c'è niente da impedirti di trasformare tutti i punti dati in un diverso sistema di coordinate. Ma a differenza di questi esempi, nell'attività di data mining spesso c'è un sistema di coordinate preferito, definito non da una convenzione esterna ma dai dati stessi. Qualunque sia la coordinazione che usi, la nuvola dei punti ha una certa varianza in ogni direzione, indicando il grado di diffusione attorno al valore medio in quella direzione. E 'un fatto curioso che se si aggiungono le varianze lungo ciascun asse e poi trasformano i punti in un sistema di coordinate diverso e fanno lo stesso, si ottiene la stessa varianza totale in entrambi i casi. Ciò è sempre vero purché i sistemi di coordinate siano ortogonali, cioè ogni asse è ad angolo retto rispetto agli altri.

   L'idea di analisi dei componenti principali è quella di utilizzare un particolare sistema di coordinate che dipende dalla nube dei punti come segue: posizionare il primo asse nella direzione della massima varianza dei punti per massimizzare la varianza lungo quel asse. Il secondo asse è perpendicolare ad esso. In due dimensioni non esiste alcuna scelta - la sua direzione è determinata dal primo asse - ma in tre dimensioni può trovarsi ovunque nel piano perpendicolare al primo asse e in dimensioni più elevate c'è ancora più scelta, sebbene sia costantemente vincolata Essere perpendicolare al primo asse. A seconda di questo vincolo, scegliere il secondo asse nel modo che massimizza la varianza lungo di essa. Continuare, scegliendo ogni asse per massimizzare la quota della restante varianza.

  Come fai a fare questo? Non è difficile, dato un programma informatico appropriato e non è difficile capire, dato gli strumenti matematici appropriati. Tecnicamente - per coloro che capiscono i termini corsivi - calcolate la matrice di covarianza delle coordinate originali dei punti e la diagonali per trovare gli autovettori. Questi sono gli assi dello spazio trasformato, ordinati in ordine di autovalore, poiché ogni autovalore dà la varianza lungo il suo asse.

  La Figura 7.5 mostra il risultato della trasformazione di un particolare set di dati con 10 attributi numerici, corrispondenti a punti nello spazio tridimensionale. Immaginate il set di dati originale come nuvola di punti in 10 dimensioni, non possiamo disegnarlo! Scegli il primo asse lungo la direzione della più grande varianza, la seconda perpendicolare ad essa lungo la direzione della prossima varianza più grande e così via. La tabella fornisce la varianza lungo ciascun nuovo asse di coordinate nell'ordine in cui sono stati scelti gli assi. Poiché la somma delle varianze è costante indipendentemente dal sistema di coordinate, vengono espresse come percentuali di quel totale. Chiamiamo componenti assi e diciamo che ognuno "rappresenta" la propria quota della varianza. La Figura 7.5 (b) elabora la varianza che ogni componente rappresenta per il numero del componente. Puoi utilizzare tutti i componenti come nuovi attributi per l'estrazione dei dati, oppure puoi scegliere solo i primi, i componenti principali e scartare il resto. In questo caso, tre componenti principali rappresentano l'84% della varianza nel set di dati; Sette rappresentano più del 95%.

 

Figure 7.5 Principal components transform of a dataset: (a) variance of each component and (b) variance plot.


  Nei set di dati numerici è comune utilizzare l'analisi dei componenti principali prima dell'estrazione dei dati come forma di pulizia dei dati e generazione di attributi. Ad esempio, si potrebbe desiderare di sostituire gli attributi numerici con gli assi principali del componente o con un sottoinsieme di essi che rappresenta una determinata proporzione - ad esempio, il 95% - della varianza. Si noti che la scala degli attributi influenza l'esito dell'analisi dei componenti principali ed è pratica comune standardizzare tutti gli attributi a zero di media e di unità di varianza in primo luogo. Un'altra possibilità è quella di applicare ricorsivamente l'analisi dei componenti principali in un discente di un albero decisionale. Ad ogni stadio un apprendente ordinario dell'albero di decisione sceglie di dividere in una direzione parallela ad uno degli assi. Tuttavia, supponiamo che una prima trasformazione dei componenti sia eseguita innanzitutto e il discente sceglie un asse nello spazio trasformato. Questo equivale a una spaccatura lungo una linea obliqua nello spazio originale. Se la trasformazione viene eseguita nuovamente prima di ogni divisione, il risultato sarà un albero di decisione multivariato le cui divisioni sono in direzioni non parallele con gli assi o tra loro.
  Random projections

 L'analisi dei componenti principali trasforma linearmente i dati in uno spazio di dimensione inferiore. Ma è costoso. Il tempo necessario per trovare la trasformazione (che è una matrice che comprende gli autovettori della matrice di covarianza) è cubica nel numero di dimensioni. Questo rende impossibile per i set di dati con un gran numero di attributi. Un'alternativa molto più semplice è quella di utilizzare una proiezione casuale dei dati in uno spazio sottostante con un numero predeterminato di dimensioni. È molto facile trovare una matrice di proiezione casuale. Ma sarà un bene? 

  In realtà, la teoria mostra che le proiezioni casuali preservano in media le relazioni di distanza abbastanza bene. Ciò significa che potrebbero essere utilizzati in combinazione con alberi di kD o alberi a sfera per fare la ricerca di prossimità più vicina in spazi con un numero enorme di dimensioni. Prima trasformare i dati per ridurre il numero di attributi; Poi costruisci un albero per lo spazio trasformato. Nel caso della classificazione di prossimità più vicina è possibile rendere il risultato più stabile e meno dipendente dalla scelta della proiezione casuale, costruendo un classificatore di insieme che utilizza più matrici casuali.
     Non sorprende che le proiezioni casuali eseguano peggio di quelle scelte accuratamente dall'analisi dei componenti principali quando utilizzati per elaborare i dati pre-elaborati per una serie di classificatori standard. Tuttavia, i risultati sperimentali hanno dimostrato che la differenza non è troppo grande e che tende a diminuire come aumenta il numero di dimensioni. E, naturalmente, le proiezioni casuali sono molto più economiche in termini computazionali.
  Text to attribute vectors

  Nella sezione 2.4 abbiamo introdotto gli attributi di stringa che contengono pezzi di testo e hanno osservato che il valore di un attributo di stringa è spesso un documento intero. Gli attributi di stringa sono fondamentalmente nominali, con un numero non specificato di valori. Se vengono trattati semplicemente come attributi nominali, possono essere costruiti modelli che dipendono dal fatto che i valori di due attributi di stringa siano uguali o meno. Ma ciò non cattura alcuna struttura interna della stringa o mette in evidenza aspetti interessanti del testo che rappresenta.

  Potresti immaginare di decomporre il testo in un attributo di stringa in paragrafi, frasi o frasi. Generalmente, tuttavia, la parola è l'unità più utile. Il testo in un attributo di stringa è di solito una sequenza di parole e spesso è meglio rappresentata in termini di parole che contiene. Ad esempio, è possibile trasformare l'attributo stringa in un insieme di attributi numerici, uno per ogni parola, che rappresenta la frequenza di visualizzazione della parola. L'insieme di parole - cioè l'insieme di nuovi attributi - è determinato dal set di dati e di solito è abbastanza grande. Se ci sono diversi attributi di stringa le cui proprietà devono essere trattate separatamente, i nuovi nomi degli attributi devono essere distinti, forse da un prefisso determinato dall'utente.

   La conversione in parole-tokenizzazione - non è un'operazione così semplice in quanto suona. I gettoni possono essere formati da sequenze alfabetiche contigue con caratteri non alfabetici scartati. Se i numeri sono presenti, anche le sequenze numeriche possono essere mantenute. I numeri possono comportare segni + o - possono contenere punti decimali e possono avere una notazione esponenziale - in altre parole, devono essere analizzati in base a una definita sintassi di numero. Una sequenza alfanumerica può essere considerata come un singolo token. Forse il carattere spaziale è il delimitatore del token; Forse lo spazio bianco (tra cui la linguetta e i caratteri della nuova linea) è il delimitatore, e forse anche la punteggiatura. I periodi possono essere difficili: talvolta dovrebbero essere considerati parte della parola (ad esempio, con iniziali, titoli, abbreviazioni e numeri), ma a volte non dovrebbero (ad esempio, se sono dei delimitatori delle frasi). I trattini e gli apostrofi sono analogamente problematici.

  Tutte le parole possono essere convertite in minuscole prima di essere aggiunte al dizionario. Le parole su una lista fissa e predeterminata di parole di funzione o di parole chiave come le e, e, ma, potrebbero essere ignorate. Tenere presente che gli elenchi delle parole chiave dipendono dalla lingua. Infatti, così sono anche le convenzioni di capitalizzazione (tedesco capitalizza tutti i nomi), la sintassi di numero (gli europei utilizzano la virgola per un punto decimale), le convenzioni di punteggiatura (lo spagnolo ha un punto interrogativo iniziale) e, naturalmente, i set di caratteri. Il testo è complicato!
  Anche le parole a bassa frequenza come hapax legomena3 vengono spesso scartate. A volte si ritiene utile mantenere le parole più frequenti k dopo che le parole di stop sono state rimosse - o forse le parole di alto livello k per ogni classe.

Oltre a tutte queste opzioni di cancellazione, c'è anche la questione di quale valore debba essere l'attributo di ogni parola. Il valore può essere il conteggio di parole: il numero di volte che la parola appare nella stringa o può semplicemente indicare la presenza o l'assenza della parola. Le frequenze di parola potrebbero essere normalizzate per dare il vettore di attributo di ogni documento la stessa lunghezza euclidea. In alternativa, le frequenze fij per parola i nel documento j possono essere trasformate in vari modi standard. Una misura di frequenza logaritmica standard è log (1 + fi). Una misura che è ampiamente utilizzata nel recupero delle informazioni è TF * IDF, o "Frequenza di termine frequenza inversa del documento". Qui, la frequenza di termine è modulata da un fattore che dipende da come comunemente la parola viene utilizzata in altri documenti. La metrica TF * IDF viene definita tipicamente come

  ....

  L'idea è che un documento è caratterizzato essenzialmente dalle parole che appaiono spesso in esso, che rappresenta il primo fattore, a meno che le parole utilizzate in ogni documento o quasi ogni documento siano inutili come discriminatori, il che rappresenta il secondo. TF ¥ IDF viene utilizzato per riferirsi non solo a questa particolare formula ma anche a una classe generale di misure dello stesso tipo. Ad esempio, il fattore di frequenza fij può essere sostituito da un termine logaritmico come il log (1 + fi l).
   Time series

  Nei dati della serie temporale, ogni istanza rappresenta un passaggio temporale diverso e gli attributi forniscono valori associati a quel tempo, come ad esempio nella previsione meteorologica o nella previsione del mercato azionario. A volte è necessario essere in grado di sostituire il valore dell'attributo nell'istanza corrente con il valore corrispondente in un'altra istanza in passato o in futuro. È ancora più comune sostituire il valore di un attributo con la differenza tra il valore corrente e il valore in un'istanza precedente. Ad esempio, la differenza - spesso chiamata Delta - tra il valore attuale e quello precedente è spesso più informativo del valore stesso. La prima istanza, in cui il valore temporizzato è sconosciuto, può essere rimosso o sostituito con un valore mancante. Il valore Delta è essenzialmente la prima derivata scalata da una costante che dipende dalla dimensione del passo di tempo. Le successive trasformazioni Delta prendono derivati più alti.

   In alcune serie temporali, le istanze non rappresentano campioni regolari, ma l'ora di ogni istanza è data da un attributo timestamp. La differenza tra i timbri è la dimensione del passo per quella istanza e se vengono presi differenze successive per altri attributi, dovrebbero essere suddivisi per la dimensione del passo per normalizzare il derivato. In altri casi, ogni attributo può rappresentare un tempo diverso, anziché ogni istanza, in modo che la serie temporale sia da un attributo al successivo piuttosto che da un'istanza all'altra. Quindi, se le differenze sono necessarie, devono essere presi tra il valore di un attributo e il valore dell'attributo successivo per ogni istanza.
  Automatic data cleansing

  Un problema che pregiudica l'estrazione pratica dei dati è una scarsa qualità dei dati. Gli errori in grandi database sono estremamente comuni. Anche i valori di attributo ei valori di classe sono spesso inaffidabili e danneggiati. Anche se un modo per affrontare questo problema è quello di controllare accuratamente i dati, le tecniche di data mining possono aiutare a risolvere il problema.
  Improving decision trees

  È un fatto sorprendente che gli alberi decisionali indotti dai dati formativi possono spesso essere semplificati, senza perdita di precisione, scartando istanze erroneamente classificate dall'insieme di addestramento, ricollegando e poi ripetendo finché non ci sono casi erronei. Gli esperimenti sui set di dati standard hanno dimostrato che questo non influenza difficilmente l'accuratezza di classificazione di C4.5, un sistema standard di induzione degli alberi decisionali. In alcuni casi migliora leggermente; In altri si deteriora leggermente. La differenza è raramente statisticamente significativa - e anche quando è, il vantaggio può andare in entrambi i modi. Quanto influisce la tecnica è la dimensione dell'albero di decisione. Gli alberi risultanti sono invariabilmente molto più piccoli di quelli originali, anche se eseguono circa lo stesso.

  Qual è la ragione di questo? Quando un 'metodo di induzione di un albero di decisione' 'elimina' un sottogruppo, si applica un test statistico che decide se il sottotesto è "giustificato" dai dati. La decisione di "eliminare" accetta un piccolo sacrificio nell'accuratezza della classificazione sul set di formazione nella convinzione che questo migliorerà le prestazioni test-set. 'Alcune istanze di formazione' che sono state classificate correttamente dall'albero non trattato saranno ora classificate in modo errato dal potato. In effetti, è stata presa la decisione di ignorare questi esercizi formativi.
Ma questa decisione è stata applicata solo localmente, nel sottogruppo eliminato. Il suo effetto non è stato permesso di percolare ulteriormente l'albero, forse con conseguente scelte differenti di attributi per il ramo. Rimuovere le istanze erronee dal set di allenamento e ricollegare l'albero decisionale mentre "sta prendendo" le decisioni di potatura alla loro conclusione logica. Se la strategia di potatura è buona, ciò non dovrebbe nuocere alla prestazione. Può perfino migliorarla permettendo di scegliere meglio scelte di attributo.

  Senza dubbio sarebbe meglio consultare un esperto umano. Le istruzioni di formazione non classificate potrebbero essere presentate per la verifica e quelle che sono state trovate sbagliate potrebbero essere cancellate o meglio ancora, corrette.
  Si noti che stiamo supponendo che le istanze non siano classificate in modo errato "in qualsiasi modo sistematico". Se le istanze sono danneggiate sistematicamente sia in kit di allenamento che in serie di test, un valore di classe potrebbe essere sostituito da un altro; è solo prevedibile che la formazione sul set di addestramento errato avrebbe reso migliori prestazioni sul set di test (anche errato).

  È interessante notare che è stato dimostrato che quando viene aggiunto un disturbo artificiale agli attributi (piuttosto che a classi), la prestazione test-set migliora se lo stesso rumore viene aggiunto allo stesso modo del set di allenamento. In altre parole, quando il disturbo dell'attributo è il problema, non è una buona idea addestrare su un set "pulito" se la prestazione deve essere valutata su un "sporco". Un metodo di apprendimento può imparare a compensare il rumore degli attributi, in una certa misura, se viene data una probabilità. In sostanza, può capire quali attributi sono inaffidabili e, se sono tutti inaffidabili, come meglio utilizzarli insieme per ottenere un risultato più affidabile. Per rimuovere il rumore dagli attributi per il set di allenamento nega l'opportunità di imparare come combattere meglio quel rumore. Ma con rumore di classe (anziché rumore di attributo), è meglio allenarsi su casi senza rumori, se possibile.
   Robust regression

  I problemi causati da dati rumorosi sono noti, per la regressione lineare, da anni. Gli statisticisti spesso controllano i dati per gli outlier e li rimuovono manualmente. Nel caso della regressione lineare, gli outlier possono essere identificati visivamente anche se non è mai completamente chiaro se un outlier è un errore o un valore sorprendente, ma corretto. Gli outliers influenzano drasticamente la solita regressione dei minimi quadrati perché la misura a distanza quadrata accentua l'influenza dei punti lontani dalla linea di regressione.

  I metodi statistici che affrontano il problema degli outlier sono chiamati robusti. Un modo per rendere più regolare la regressione è quello di utilizzare una misura a distanza assoluta invece del solito quadrato. Questo indebolisce l'effetto degli outliers. Un'altra possibilità è cercare di identificare automaticamente gli outlier e rimuoverli dalla considerazione. Ad esempio, si potrebbe formare una linea di regressione e quindi rimuovere dalla considerazione il 10% dei punti che si trovano più lontani dalla linea. Una terza possibilità è ridurre al minimo la media (piuttosto che la media) dei quadrati delle divergenze dalla linea di regressione. Si scopre che questo stimatore è molto robusto ed effettivamente combina con outliers nella direzione X così come outliers nella direzione Y - che è la direzione normale che si pensa di outliers.

  Un set di dati spesso utilizzato per illustrare una regressione robusta è il grafico delle telefonate internazionali effettuate dal Belgio dal 1950 al 1973, mostrate nella Figura 7.6. Questi dati sono tratti dall'indagine statistica belga pubblicata dal Ministero dell'Economia. La trama sembra mostrare una tendenza al rialzo nel corso degli anni, ma esiste un gruppo di punti anomalo dal 1964 al 1969. Risulta che durante questo periodo i risultati sono stati erroneamente registrati nel numero totale di minuti delle chiamate. Gli anni 1963 e 1970 sono anche parzialmente colpiti. Questo errore provoca una grande frazione di outliers nella direzione Y.

  Non sorprende che la solita linea di regressione a minori quadrati sia gravemente influenzata da questi dati anomali. Tuttavia, la linea mediana minore di quadrati resta notevolmente imperturbabile. Questa linea ha un'interpretazione semplice e naturale. Geometrico, corrisponde alla ricerca della striscia più stretta che copre metà delle osservazioni, dove lo spessore della striscia è misurato in direzione verticale, questa striscia è contrassegnata grigio in Figura 7.6; È necessario guardare da vicino per vederlo.La linea mediana minore di quadrati sta nel centro esatto di questa fascia. Si noti che questa nozione è spesso più facile da spiegare e visualizzare rispetto alla normale definizione di regressione minima quadrati. Purtroppo, c'è un grave svantaggio per le tecniche di regressione basate sul mediano: hanno un elevato costo computazionale, che spesso li rende impossibili per problemi pratici.


Figure 7.6 Number of international phone calls from Belgium, 1950–1973.


  Detecting anomalies - Individuazione di anomalie

  Un grave problema con qualsiasi forma di rilevamento automatico di dati apparentemente errati è che il bambino può essere gettato fuori con l'acqua del bagno. A dispetto della consultazione di un esperto umano, non esiste veramente alcun modo di dire se un'istanza particolare sia veramente un errore o se semplicemente non si inserisce il tipo di modello che viene applicato. Nella regressione statistica, le visualizzazioni aiutano. Di solito è visivamente apparente, anche al non esperto, se si inserisce una curva sbagliata, ad esempio viene applicata una linea retta per i dati che si trova su una parabola. Gli outliers della Figura 7.6 sono sicuramente all'occhio. Ma la maggior parte dei problemi non può essere così facilmente visualizzata: la nozione di "tipo di modello" è più sottile di una linea di regressione. E anche se è noto che ottimi risultati sono ottenuti sulla maggior parte dei set di dati standard scartando istanze che non si inseriscono in un modello di albero decisionale, questo non è necessariamente di grande comodità quando si tratta di un particolare set di dati nuovo. Il sospetto rimarrà che forse il nuovo set di dati è semplicemente inadatto alla modellazione degli alberi decisionali.

   Una soluzione che è stata provata è quella di utilizzare diversi "schemi di apprendimento", come ad esempio un albero di decisione e un discente più vicino e una funzione discriminante lineare, per filtrare i dati. Un approccio conservativo è quello di chiedere che tutti e tre i sistemi non riescano a classificare correttamente un'istanza prima che sia ritenuto errato e rimosso dai dati. In alcuni casi, filtrando i dati in questo modo e utilizzando i dati filtrati come input in un sistema di apprendimento finale, si ottiene una prestazione migliore rispetto a un semplice utilizzo dei tre schemi di apprendimento e la possibilità di votare sul risultato. Formare tutti e tre i regimi sui dati filtrati e lasciarli votare possono dare risultati ancora migliori. Tuttavia, esiste un pericolo per le tecniche di voto: alcuni algoritmi di apprendimento sono più adatti a determinati tipi di dati rispetto ad altri e il metodo più appropriato può semplicemente uscire dalla votazione! Esamineremo un metodo più sottile per combinare l'output di classificatori diversi, chiamati impilamento, nella sezione successiva. La lezione, come al solito, è conoscere i tuoi dati e guardarla in molti modi diversi.

  Un possibile pericolo con gli approcci di filtraggio è che essi potrebbero concepire semplicemente sacrificando istanze di una particolare classe (o gruppo di classi) per migliorare la precisione delle restanti classi. Anche se non esistono modi generali per evitare questo, non è stato trovato come un problema comune nella pratica.
  Infine, vale la pena di notare ancora una volta che il filtraggio automatico è un povero sostituto per ottenere i dati giusti in primo luogo. Se questo è troppo tempo e costoso per essere pratico, l'ispezione umana potrebbe essere limitata a quei casi che sono identificati dal filtro come sospetti.
  Combining multiple models

  Quando le persone sagge fanno decisioni critiche, di solito prendono in considerazione i pareri di diversi esperti piuttosto che affidarsi al proprio giudizio o a quello di un solitario consulente fidato. Ad esempio, prima di scegliere una nuova direzione politica importante, un dittatore benigno consulta molto: lui o lei sarebbe stato mal consigliato di seguire ciecamente un parere di un esperto. In un contesto democratico, la discussione di diversi punti di vista può produrre un consenso; Se no, può essere richiesto un voto. In entrambi i casi, vengono combinati diversi pareri di esperti.

  Nell'esportazione dei dati, un modello generato dall'applicazione della macchina può essere considerato come un esperto. Esperto è probabilmente una parola troppo forte! - a seconda della quantità e della qualità dei dati formativi e se l'algoritmo di apprendimento è appropriato al problema in questione, l'esperto può in verità essere purtroppo ignorante - ma noi usiamo comunque il termine. Un approccio evidente per rendere le decisioni più affidabili è combinare l'output di diversi modelli. Diverse tecniche di apprendimento automatico fanno questo imparando un insieme di modelli e utilizzandoli in combinazione: tra questi sono noti protagonisti i sistemi chiamati imbottigliamento, potenziamento e impilamento. Possono tutti, più spesso, aumentare le prestazioni predittive su un singolo modello. E sono tecniche generali che possono essere applicate ai problemi di previsione numerica e alle attività di classificazione.

  Bagging, boosting e stacking sono stati sviluppati solo negli ultimi dieci anni, e la loro performance è spesso sorprendentemente buona. I ricercatori di apprendimento delle macchine hanno lottato per capire perché. E durante quella lotta sono emersi nuovi metodi che talvolta sono ancora migliori. Ad esempio, mentre i comitati umani raramente usufruiscono di distrazioni rumorose, scuotendo l'imbottigliamento aggiungendo varianti casuali di classificatori possono migliorare le prestazioni. L'analisi più stretta ha rivelato che l'amplificazione - forse il più potente dei tre metodi - è strettamente connessa alla tecnica statistica stabilita di modelli additivi e questa realizzazione ha portato a procedure migliorate.

  Questi modelli combinati condividono lo svantaggio di essere difficili da analizzare: possono comprendere decine o addirittura centinaia di modelli individuali e, anche se funzionano bene, non è facile capire in termini intuitivi quali fattori contribuiscono alle decisioni migliorate. Negli ultimi anni sono stati sviluppati metodi che combinano i vantaggi delle prestazioni dei comitati con modelli comprensibili. Alcuni producono modelli di albero di decisione standard; Altri introducono nuove varianti di alberi che forniscono percorsi opzionali. Chiudiamo introducendo un'ulteriore tecnica di combinazione di modelli utilizzando i codici di output di correzione degli errori. Questo è più specializzato delle altre tre tecniche: si applica solo ai problemi di classificazione, e anche solo a quelli che hanno più di tre classi.
  Bagging

  Combinando le decisioni di diversi modelli significa amalgamare le varie uscite in una singola previsione. Il modo più semplice per farlo in caso di classificazione è quello di votare (forse un voto ponderato); Nel caso di previsione numerica, è quello di calcolare la media (forse una media ponderata). Baging e boosting entrambi adottano questo approccio, ma derivano i modelli individuali in modi diversi. Nel saccheggio, i modelli ricevono un peso uguale, mentre in aumento, la ponderazione viene utilizzata per dare più influenza a quelli più efficaci, proprio come un dirigente potrebbe inserire valori diversi sulla consulenza di diversi esperti a seconda di quanto siano esperti.

  Per introdurre il "baging", supponiamo che diversi set di dati di formazione della stessa dimensione siano scelti a caso dal dominio del problema. Immagina di utilizzare una particolare tecnica di apprendimento macchina per costruire una struttura di decisione per ogni set di dati. Potreste prevedere che questi alberi siano praticamente identici e fare la stessa previsione per ogni nuova istanza di test. Sorprendentemente, questo assunto è di solito piuttosto sbagliato, soprattutto se i set di dati di formazione sono piuttosto piccoli. Questo è un fatto piuttosto inquietante e sembra lanciare un'ombra su tutta l'impresa! Il motivo è che l'induzione di un albero di decisione (almeno il metodo top-down standard descritto nel capitolo 4) è un processo instabile: piccole modifiche ai dati di formazione possono facilmente determinare un diverso attributo scelto in un particolare nodo, Ramificazioni significative per la struttura del sotto-albero sotto quel nodo. Ciò implica automaticamente che ci sono istanze di prova per cui alcuni alberi di deciosione producono previsioni corrette e altri non lo fanno.

  Ritornando all'analogia degli esperti precedenti, considerate gli esperti come gli alberi decisionali individuali. Possiamo combinare gli alberi facendo voto su ciascuna istanza di prova. Se una classe riceve più voti di qualsiasi altra cosa, viene considerata come quella corretta. In linea di massima, più è più meraviglioso: le previsioni generate dal voto diventano più affidabili, in quanto si prendono in considerazione più voti. Le decisioni si peggiorano raramente se vengono scoperti nuovi set di formazione, per loro sono stati creati alberi, e le loro previsioni partecipano anche al voto. In particolare, il classificatore combinato raramente sarà meno preciso di un albero decisionale costruito da un solo set di dati. (Tuttavia, non è garantito un miglioramento. Si può dimostrare teoricamente che esistono situazioni patologiche in cui le decisioni combinate sono peggiori.)

  L'effetto della combinazione di più ipotesi può essere visto attraverso un dispositivo teorico noto come la decomposizione della bias-variance. Supponiamo che possiamo avere un numero infinito di gruppi di allenamento indipendenti della stessa dimensione e utilizzarli per fare un numero infinito di classificatori. Un'istanza di prova viene elaborata da tutti i classificatori e una sola risposta è determinata a maggioranza. In questa situazione idealizzata, gli errori verranno ancora verificati in quanto nessun schema di apprendimento è perfetto: il tasso di errore dipenderà dal modo in cui il metodo di apprendimento della macchina corrisponde al problema in questione e vi è anche l'effetto di rumore nei dati che non possono essere imparati. Supponiamo che il tasso di errore previsto sia stato valutato mediando l'errore del classificatore combinato su un numero infinito di esempi di test indipendentemente scelti. Il tasso di errore per un determinato algoritmo di apprendimento viene definito bias per il problema dell'apprendimento e misura quanto bene il metodo di apprendimento corrisponda al problema. Questa definizione tecnica è un modo per quantificare la nozione vaguer della bias che è stata introdotta nella Sezione 1.5: misura l'errore "persistente" di un algoritmo di apprendimento che non può essere eliminato anche prendendo in considerazione un infinito numero di corsi di formazione. Naturalmente, non può essere calcolato esattamente in situazioni pratiche; Può essere approssimato.

  Una seconda fonte di errore in un modello appreso, in una situazione pratica, deriva dal particolare set di formazione utilizzato, che è inevitabilmente finito e pertanto non è pienamente rappresentativo della popolazione effettiva di casi. Il valore atteso di questa componente dell'errore, su tutti i possibili set di addestramento della dimensione indicata e tutti i possibili set di test, è chiamata la varianza del metodo di apprendimento per quel problema. L'errore totale previsto di un classificatore è costituito dalla somma di polarizzazione e di varianza: questa è la decomposizione della variazione di bias. Combinando più classificatori riduce l'errore atteso riducendo la componente della varianza. Più classificatori inclusi, maggiore sarà la riduzione della varianza. Naturalmente, sorge una difficoltà nel mettere in pratica questo metodo di voto: di solito c'è solo un set di formazione, e ottenere maggiori dati è impossibile o costoso.

   Il baging tenta di neutralizzare l'instabilità dei metodi di apprendimento simulando il processo descritto in precedenza utilizzando un set di formazione specificato. Invece di prelevare ogni volta un nuovo dataset di formazione indipendente, i dati di formazione originali vengono modificati eliminando alcune istanze e replicando altri. Le istanze vengono campionate in modo casuale, con sostituzione, dal dataset originale per creare una nuova delle medesime dimensioni. Questa procedura di campionamento replica inevitabilmente alcune delle istanze e elimina altri. Se questa idea colpisce un accordo, è perché abbiamo descritto nel capitolo 5 quando si spiega il metodo di bootstrap per la stima dell'errore di generalizzazione di un metodo di apprendimento (Sezione 5.4): infatti, il termine bagging indica l'aggregazione di bootstrap. Bagging applica lo schema di apprendimento - ad esempio, un induttore di alberi decisionali - ad ognuno di questi set di dati artificialmente derivati e dei classificatori generati da loro votano per la classe da prevedere. L'algoritmo è riassunto in Figura 7.7.

  La differenza tra il bagaglio e la procedura idealizzata descritta in precedenza è il modo in cui vengono tracciati i set di dati di formazione. Invece di ottenere i set di dati indipendenti dal dominio, l'imballaggio contiene solo i resoconti dei dati di formazione originali. I set di dati generati dal riesaminamento sono diversi tra loro, ma non sono certamente indipendenti perché tutti sono basati su un set di dati. Tuttavia, si scopre che il «baging» produce un modello combinato che spesso esegue significativamente meglio il modello singolo costruito dai dati di formazione originali e non è mai peggiorato.


Figure 7.7 Algorithm for bagging.


  Bagging può essere applicato anche ai metodi di apprendimento per la previsione numerica, ad esempio, alberi modello. L'unica differenza è che, invece di votare sul risultato, le previsioni individuali, essendo numeri reali, sono mediati. La decomposizione della varianza di bias può essere applicata alla previsione numerica anche mediante la decomposizione del valore atteso dell'errore medio delle predizioni sui dati freschi. La bias è definita come l'errore medio quadrato previsto per la mediazione su modelli costruiti da tutti i possibili set di dati di formazione della stessa dimensione e la varianza è la componente dell'errore previsto di un singolo modello che è dovuto ai dati di formazione specifici che è stato costruito . Può essere dimostrato teoricamente che la mediazione su più modelli costruiti da gruppi di allenamento indipendenti riduce sempre il valore atteso dell'errore medio-quadrato. (Come abbiamo già detto, il risultato analogo non è vero per la classificazione.)
  Bagging with costs

  Bagging aiuta maggiormente se il metodo di apprendimento sottostante è instabile in quanto piccoli cambiamenti nei dati di input possono portare a classificatori molto diversi. Infatti può contribuire ad aumentare la diversità nell'insieme dei classificatori rendendo il metodo di apprendimento il più instabile possibile. Ad esempio, quando si assorbono gli alberi decisionali, che sono già instabili, le prestazioni migliori vengono spesso ottenute passando la potatura, che li rende ancora più instabili. Un altro miglioramento può essere ottenuto cambiando il modo in cui le previsioni sono combinate per la classificazione. Come originariamente formulato, il bagaglio usa il voto. Ma quando i modelli possono produrre stime di probabilità e non solo classificazioni semplici, rende intuitivo il senso di mediare queste probabilità invece. Non solo questo migliora spesso la classificazione leggermente, ma il classificatore a sacco crea anche stime di probabilità - spesso più accurate di quelle prodotte dai singoli modelli. Le implementazioni del bagaglio usano comunemente questo metodo di combinazione delle previsioni.

  Nella Sezione 5.7 abbiamo mostrato come fare un classificatore a costi sensibili riducendo al minimo il costo previsto delle previsioni. Le stime di probabilità accurate sono necessarie perché vengono utilizzate per ottenere il costo previsto di ogni previsione. Bagging è un candidato primario per la classificazione dei costi, perché produce stime molto accurate di probabilità da alberi decisionali e altri classificatori potenti, ma instabili. Tuttavia, uno svantaggio è che i classificatori a sacco sono difficili da analizzare.

  Un metodo chiamato MetaCost combina i vantaggi predittivi del bagaglio con un modello comprensibile per la previsione dei costi. Costruisce un classificatore di ensemble che utilizza il bagaglio e lo usa per rielaborare i dati di addestramento fornendo ad ogni istanza di formazione la previsione che minimizza il costo previsto, sulla base delle stime di probabilità ottenute dal bagaglio. MetaCost scarta quindi le etichette di classe originali e impara un singolo nuovo classificatore - ad esempio un singolo albero di decisione «potato» - dai dati ridefiniti. Questo nuovo modello prende automaticamente in considerazione i costi perché sono stati inseriti nelle etichette di classe! Il risultato è un singolo classificatore sensibile al costo che può essere analizzato per vedere come vengono fatte le previsioni.

  Oltre alla tecnica di classificazione "sensibile ai costi" appena menzionata, la sezione 5.7 descrive anche un metodo di apprendimento "sensibile ai costi" che impara un classificatore sensibile ai costi modificando la percentuale di ciascuna classe nei dati di addestramento per riflettere la matrice di costo. MetaCost sembra produrre risultati più accurati di questo metodo, ma richiede più calcolo. Se non c'è bisogno di un modello comprensibile, la fase di postprocesso di MetaCost è superflua: è meglio utilizzare il classificatore a sacco direttamente in combinazione con il metodo minimo di costo previsto.
  Randomization

  Bagging genera un insieme diversificato di classificatori introducendo la casualità nell'ingresso algoritmo di apprendimento, spesso con ottimi risultati. Ma ci sono altri modi per creare la diversità introducendo la randomizzazione. Alcuni algoritmi di apprendimento hanno già un componente casuale integrato. Ad esempio, quando imparano i perceproni multilayer utilizzando l'algoritmo di backpropagation (come descritto nella sezione 6.3), i pesi di rete sono impostati su valori scelti casualmente. Il classificatore imparato dipende dai numeri casuali perché l'algoritmo può trovare un diverso minimo locale della funzione di errore. Un modo per rendere più stabile il risultato della classificazione è quello di eseguire diverse volte il discente con diversi numeri di numero casuale e combinare le previsioni dei classificatori per votazione o mediazione.

   Quasi tutti i metodi di apprendimento sono suscettibili di una sorta di randomizzazione. Consideriamo un algoritmo che scelto con ansia l'opzione migliore ad ogni passo, ad esempio un elemento che decide l'attributo migliore da dividere in ogni nodo. Potrebbe essere randomizzato scegliendo in modo casuale una delle migliori opzioni N invece di un singolo vincitore o scegliendo un sottoinsieme di opzioni casuale e scegliendo il meglio da quello. Naturalmente, c'è un compromesso: più casualità genera più varietà nello studente ma rende meno utilizzati i dati, probabilmente diminuendo l'accuratezza di ogni singolo modello. La migliore dose di casualità può essere prescritta solo mediante esperimento.
     Sebbene il bagaglio e la randomizzazione producano risultati simili, a volte si paga per combinarli perché introducono casualità in modi diversi, forse complementari. Un algoritmo popolare per l'apprendimento delle foreste casuali costruisce un albero di decisione randomizzato in ogni iterazione dell'algoritmo di bagaglio e spesso produce ottimi predittori.

  La randomizzazione richiede più lavoro di "baging" perché l'algoritmo di apprendimento deve essere modificato, ma può essere applicato con profitto ad una maggiore varietà di discenti. Abbiamo notato in precedenza che l'imbottigliamento non funziona con algoritmi di apprendimento stabili la cui produzione è insensibile a piccoli cambiamenti nell'ingresso. Ad esempio, è inutile mettere in borsa i classificatori vicini più vicini perché la loro produzione cambia molto poco se i dati di allenamento sono perturbati dal campionamento. Ma la randomizzazione può essere applicata anche a studenti stabili: il trucco è quello di randomizzare in un modo che rende i classificatori diversi senza sacrificare troppe prestazioni. Le previsioni di una classificatrice di prossimità più vicina dipendono dalle distanze tra le istanze, che a sua volta dipendono fortemente da quali attributi vengono utilizzati per calcolarli, per cui i classificatori più vicini possono essere randomizzati utilizzando diversi sottoinsiemi di attributi selezionati in modo casuale.
  Boosting

  Abbiamo spiegato che il bagging sfrutta l'instabilità inerente agli algoritmi di apprendimento. Intuitivamente, unendo più modelli aiuta solo quando questi modelli sono significativamente diversi l'uno dall'altro e quando ciascuno tratta una percentuale ragionevole dei dati correttamente. Idealmente, i modelli si completano, ognuno di essi è uno specialista in una parte del dominio dove gli altri modelli non funzionano molto bene, proprio come i dirigenti umani cercano consulenti le cui competenze e l'esperienza complementano, piuttosto che duplicare, l'un l'altro.

  Il metodo di rafforzamento per la combinazione di modelli multipli sfrutta questa intuizione cercando esplicitamente modelli che si completano a vicenda. Innanzitutto, le somiglianze: come l'imbottigliamento, aumentando l'uso dei voti (per la classificazione) o la media (per la previsione numerica) per combinare l'output di singoli modelli. Ancora una volta come l'imballaggio, combina modelli dello stesso tipo - ad esempio, alberi decisionali. Tuttavia, il potenziamento è iterativo. Mentre nella confezione di singoli modelli sono costruiti separatamente, per incrementare ogni nuovo modello è influenzato dalle prestazioni di quelle costruite in precedenza. Boosting incoraggia nuovi modelli a diventare esperti per casi trattati in modo non corretto da quelli precedenti. Una differenza finale è che aumentare i pesi di un modello di contributo per la sua performance piuttosto che dare pari peso a tutti i modelli.

  Ci sono molte varianti sull'idea di "boosting". Descriviamo un metodo ampiamente utilizzato chiamato AdaBoost.M1 che è stato progettato specificamente per la classificazione. Come "baging", può essere applicato ad ogni algoritmo di classificazione di apprendimento. Per semplificare le cose, supponiamo che l'algoritmo di apprendimento possa gestire istanze ponderate, dove il peso di un'istanza è un numero positivo. La presenza di pesi di istanza modifica il modo in cui viene calcolato un errore di classificatore: è la somma dei pesi delle istanze erronee suddivise per il peso totale di tutte le istanze, anziché la frazione di istanze Che sono erroneamente classificati. Ponderando le istanze, l'algoritmo di apprendimento può essere costretto a concentrarsi su un particolare insieme di istanze, vale a dire quelle con peso elevato. Tali casi diventano particolarmente importanti perché c'è un maggiore incentivo a classificarli correttamente. L'algoritmo C4.5, descritto nella sezione 6.1, è un esempio di un metodo di apprendimento che può ospitare istanze ponderate senza modifiche perché già usa la nozione di istanze frazionarie per gestire i valori mancanti.


model generation

  Assign equal weight to each training instance.

  For each of t iterations:

  Apply learning algorithm to weighted dataset and store

  resulting model.

  Compute error e of model on weighted dataset and store error.

  If e equal to zero, or e greater or equal to 0.5:

  Terminate model generation.

  For each instance in dataset:

    If instance classified correctly by model:

    Multiply weight of instance by e / (1 – e).

    Normalize weight of all instances.

classification

  Assign weight of zero to all classes.

  For each of the t (or less) models:

    Add –log(e / (1 – e)) to weight of class predicted by model.

    Return class with highest weight.


 Figure 7.8 Algorithm for boosting.


L'algoritmo di incremento, riassunto in Figura 7.8, inizia assegnando il peso uguale a tutte le istanze nei dati di allenamento. Quindi chiama l'algoritmo di apprendimento per formare un classificatore per questi dati e ridimensiona ogni istanza secondo l'output del classificatore. Il peso di istanze classificate correttamente è diminuito e quello di quelli erronei è aumentato. Questo produce un insieme di istanze "facili" con peso ridotto e una serie di "hard" con peso elevato. Nella successiva iterazione - e tutte le successive - viene creato un classificatore per i dati ripensati, che si concentra quindi sulla classificazione corretta delle istanze dure. Quindi i pesi dei casi vengono aumentati o diminuiti in base all'uscita di questo nuovo classificatore. Di conseguenza, alcune istanze dure potrebbero diventare ancora più difficili e più semplici potrebbero diventare ancora più semplici; D'altra parte, altre istanze dure potrebbero diventare più facili e quelle più facili potrebbero diventare più difficili - tutte le possibilità possono verificarsi in pratica. Dopo ogni iterazione, i pesi riflettono quanto spesso i casi siano stati erroneamente classificati dai classificatori prodotti finora. Mantenendo una misura di "durezza" con ogni istanza, questa procedura fornisce un modo elegante per generare una serie di esperti che si completano a vicenda.

  Quanto i pesi devono essere alterati dopo ogni iterazione? La risposta dipende dall'errore complessivo dell'attuale classificatore. Più specificamente, se e indica l'errore del classificatore sui dati ponderati (una frazione tra 0 e 1), i pesi vengono aggiornati

  

  weight <- weight * e (1 - e)


  Per istanze correttamente classificate ei pesi rimangono invariati per quelli errati. Naturalmente, questo non aumenta il peso di istanze erroneamente classificate come precedentemente affermato. Tuttavia, dopo che tutti i pesi sono stati aggiornati vengono rinormalizzati in modo che la loro somma rimanga la stessa di quanto prima. Il peso di ogni istanza è diviso per la somma dei nuovi pesi e moltiplicato per la somma dei vecchi. Questo aumenta automaticamente il peso di ogni istanza erronea e riduce quella di ogni classificazione correttamente classificata.
   Ogni volta che l'errore sui dati di formazione ponderati supera o è uguale a 0,5, la procedura di incremento elimina il classificatore corrente e non esegue ulteriori iterazioni. La stessa cosa accade quando l'errore è 0, perché tutti i pesi di istanza diventano 0.

  Abbiamo spiegato come il metodo di incremento genera una serie di classificatori. Per formare una previsione, la loro produzione viene combinata usando un voto ponderato. Per determinare i pesi, si noti che un classificatore che esegue bene i dati di formazione ponderati da cui è stato costruito (e vicino a 0) dovrebbe ricevere un peso elevato e un classificatore che esegue male (e vicino a 0,5) dovrebbe ricevere un livello basso uno. Più specificamente,

....

che è un numero positivo tra 0 e infinito. Per inciso, questa formula spiega perché i classificatori che eseguono perfettamente i dati di formazione devono essere eliminati, perché quando e è 0 il peso è indefinito. Per fare una previsione, i pesi di tutti i classificatori che votano per una particolare classe sono sommati e viene scelta la classe con il più grande totale.

  Abbiamo cominciato assumendo che l'algoritmo di apprendimento possa far fronte a istanze ponderate. Abbiamo spiegato come adattare gli algoritmi di apprendimento per far fronte a istanze ponderate alla fine della sezione 6.5 sotto la regressione lineare ponderata localmente. Invece di cambiare l'algoritmo di apprendimento, è possibile generare un set di dati non ponderato dai dati ponderati mediante il riesaminamento, la stessa tecnica che utilizza bagging. Mentre per 'bagging' ogni istanza viene scelta con probabilità uguali, per 'i casi boosting' vengono scelte con probabilità proporzionale al loro peso. Di conseguenza, i casi con peso elevato vengono replicati frequentemente e quelli con peso ridotto non possono essere mai selezionati. Una volta che il nuovo set di dati diventa grande come quello originale, viene inserito nel metodo di apprendimento anziché nei dati ponderati. E 'così semplice.

   Uno svantaggio di questa procedura è che alcuni casi con peso ridotto non lo fanno nel set di dati ricampionato, quindi le informazioni vengono perse prima che il metodo di apprendimento venga applicato. Tuttavia, questo può essere trasformato in un vantaggio. Se il metodo di apprendimento produce un classificatore il cui errore supera 0,5, il potenziamento deve terminare se i dati ponderati vengono utilizzati direttamente, mentre con la ricampiunatura potrebbe essere possibile produrre un classificatore con errore inferiore a 0,5 scartando il set di dati ricampionato e generando un nuovo da un Diversi semi casuali. A volte aumentando le iterazioni può essere eseguita mediante il riesaminamento che quando si utilizza la versione ponderata originale dell'algoritmo.

  L'idea di amplificazione(boosting) è nata da un ramo della ricerca di apprendimento in macchina noto come teoria dell'apprendimento computazionale. I teorici sono interessati ad aumentare perché è possibile trarre garanzie di prestazioni. Ad esempio, può essere dimostrato che l'errore del classificatore combinato sui dati di addestramento si avvicina allo zero molto rapidamente in quanto vengono eseguite più iterazioni (esponenzialmente rapidamente nel numero di iterazioni). Purtroppo, come spiegato nella Sezione 5.1, le garanzie per l'errore di formazione non sono molto interessanti perché non necessariamente indicano buone prestazioni sui dati freschi. Tuttavia, si può dimostrare teoricamente che il potenziamento solo fallisce su dati nuovi se i singoli classificatori sono troppo "complessi" per la quantità di dati formativi presenti o se i loro errori di formazione diventano troppo grandi troppo rapidamente (in un preciso senso spiegato da Schapire et al 1997). Come al solito, il problema sta nel trovare il giusto equilibrio tra la complessità dei singoli modelli e la loro adattabilità ai dati.

  Se il "boosting" riesce a ridurre l'errore sui dati di prova nuovi, spesso lo fa in modo spettacolare. Un risultato molto sorprendente è che l'esecuzione di iterazioni più potenziate può ridurre l'errore nei nuovi dati a lungo dopo che l'errore del classificatore combinato sui dati di formazione è sceso a zero. I ricercatori sono stati perplessi da questo risultato perché sembra contraddire il rasoio di Occam, che dichiara che di due ipotesi che spiegano la prova empirica ugualmente bene, più semplice è preferibile. Esecuzione di ulteriori iterazioni incrementali senza ridurre l'errore di addestramento non spiega meglio i dati di addestramento e aggiunge certamente complessità al classificatore combinato. Fortunatamente, la contraddizione può essere risolta considerando la fiducia del classificatore nelle sue previsioni. La fiducia è misurata dalla differenza tra la probabilità stimata della classe vera e quella della classe più probabile prevista diversa dalla vera classe - una quantità nota come margine. Maggiore è il margine, più sicuro che il classificatore è nel predire la vera classe. Si scopre che il potenziamento può aumentare il margine molto tempo dopo che l'errore di allenamento è sceso a zero. L'effetto può essere visualizzato plottando la distribuzione cumulativa dei valori di margine di tutte le istanze di addestramento per diversi numeri di incremento delle iterazioni, dando un grafico conosciuto come la curva di margine. Quindi, se la spiegazione delle prove empiriche prende in considerazione il margine, il rasoio di Occam rimane sempre più forte.

  La cosa bella di stimolare(boosting) è che un potente classificatore combinato può essere costruito da quelli molto semplici purché raggiungano un errore inferiore al 50% sui dati ripensati. Di solito, questo è facile - certamente per imparare problemi con due classi! I metodi semplici di apprendimento sono chiamati studenti deboli e aumentano i convertiti dei discenti deboli in forti. Ad esempio, i buoni risultati per i problemi a due livelli possono essere ottenuti incoraggiando alberi decisionali estremamente semplici che dispongono di un unico livello chiamato ceppi di decisione. Un'altra possibilità è quella di applicare il potenziamento ad un algoritmo che apprende un'unica regola congiunta (ad esempio un singolo percorso in un albero di decisione) e classifica le istanze in base alla regola o meno. Naturalmente, i set di dati multiclassici rendono più difficile ottenere i tassi di errore inferiori a 0,5. Gli alberi decisionali possono ancora essere potenziati, ma solitamente devono essere più complessi dei ceppi di decisione. Sono stati sviluppati algoritmi sofisticati che permettono ai modelli molto semplici di essere accresciuti con successo nelle situazioni multiclass.

  "Boosting" produce spesso classificatori che sono significativamente più accurati su dati freschi di quelli generati dal "bagaglio". Tuttavia, a differenza di "baging", "boosting" a volte fallisce in situazioni pratiche: può generare un classificatore che è significativamente meno accurato di un singolo classificatore costruito dagli stessi dati. Ciò indica che il classificatore combinato sovrappone i dati.
  Regressione additiva - Additive regression

Quando è stato inizialmente studiato il "potenziamento", ha provocato un forte interesse tra i ricercatori perché potrebbe coinvolgere prestazioni di prima classe da parte degli studenti indifferenti. I statisticamente scoprirono presto che potrebbe essere ricostruito come un algoritmo avido per il montaggio di un modello additivo. I modelli additivi hanno una lunga storia nelle statistiche. In generale, il termine si riferisce a qualsiasi modo di generare le previsioni sommando i contributi ottenuti da altri modelli. La maggior parte degli algoritmi di apprendimento per i modelli additivi non costruisce i modelli di base in modo indipendente ma assicura che si completino l'un l'altro e cerchi di formare un insieme di modelli di base che ottimizzano le prestazioni predittive secondo un determinato criterio.

  L'accrescimento implica la modellazione additiva in avanti. Questa classe di algoritmi inizia con un ensemble vuoto e incorpora nuovi membri in sequenza. A ogni fase viene aggiunto il modello che massimizza la prestazione predittiva dell'intero insieme, senza alterare quelli già presenti nell'insieme. L'ottimizzazione della performance del gruppo implica che il prossimo modello dovrebbe concentrarsi su quegli esercizi di formazione su cui l'ensemble si esegue male. Questo è esattamente ciò che aumenta rendendo tali casi pesi più grandi.

  Ecco un noto metodo per la modellazione addizionale di stagne per la previsione numerica. Innanzitutto creare un modello di regressione standard, ad esempio un albero di regressione. Gli errori che esibiscono sui dati di addestramento - le differenze tra i valori previsti e quelli osservati - sono chiamati residui. Correggere quindi questi errori imparando un secondo modello - forse un altro albero di regressione - che cerca di prevedere i residui osservati. A tal fine, sostituire i valori originali della classe con i loro residui prima di apprendere il secondo modello. Aggiungendo le previsioni fatte dal secondo modello a quelle del primo, si ottiene automaticamente un errore inferiore sui dati di addestramento. Di solito alcuni residui rimangono, perché il secondo modello non è perfetto, quindi continuiamo con un terzo modello che impara a prevedere i residui dei residui e così via. La procedura è riconducibile all'uso delle regole con eccezioni per la classificazione che abbiamo incontrato nella Sezione 3.5.

  Se i singoli modelli minimizzano l'errore quadrato delle previsioni, come fanno i modelli di regressione lineare, questo algoritmo minimizza l'errore quadrato dell'intero insieme. In pratica, inoltre, funziona bene quando lo studente di base utilizza invece una approssimazione euristica, come ad esempio i regressori e gli studenti di modelli descritti nella sezione 6.5. Infatti, non c'è alcun motivo per usare la regressione lineare standard come lo studente di base per la regressione additiva, perché la somma dei modelli di regressione lineare è ancora un modello di regressione lineare e l'algoritmo di regressione riduce minimamente l'errore quadrato. Tuttavia, è una storia diversa se lo studente di base è un modello di regressione basato su un singolo attributo, quello che minimizza l'errore quadrato. Gli statisti chiamano questa semplice regressione lineare, in contrasto con il metodo multiattributo standard, chiamato correttamente regressione lineare multipla. Infatti, utilizzando la regressione additiva in combinazione con una semplice regressione lineare e l'iterazione fino a quando l'errore quadrato dell'assemblea non diminuisce ulteriormente, produce un modello additivo identico alla funzione di regressione lineare multipla di minori quadrati.

  La regressione additiva in avanti per la stagionatura è soggetta a sovrapposizione perché ogni modello aggiunto è più adatto ai dati dell'addestramento. Per decidere quando fermarsi, utilizzare la convalida incrociata. Ad esempio, eseguire una convalida incrociata per ogni numero o iterazioni fino a un massimo specificato dall'utente e scegliere quello che minimizza la stima cross-convalidata di errore quadrato. Questo è un buon criterio di arresto perché la convalida incrociata fornisce una stima abbastanza affidabile dell'errore sui dati futuri. Incidentalmente, usando questo metodo in combinazione con una semplice regressione lineare, poiché il principio di base combina la regressione lineare multipla con la selezione degli attributi incorporati, perché il contributo successivo più importante viene incluso solo se diminuisce l'errore convalidato.

   Per la comodità di implementazione, la regressione additiva in fase di lancio avviene normalmente con un modello di livello 0 che prevede semplicemente la media della classe sui dati di addestramento in modo che ogni modello successivo si adatta ai residui. Ciò suggerisce un'altra possibilità per prevenire l'overfitting: invece di sottrarre l'intera predizione di un modello per generare valori target per il modello successivo, ridurre le previsioni moltiplicandole da un fattore costante specificato dall'utente tra 0 e 1 prima di sottrarre. Ciò riduce l'adattabilità del modello ai residui e, di conseguenza, riduce la possibilità di overfitting. Naturalmente, può aumentare il numero di iterazioni necessarie per arrivare ad un buon modello di additivi. Riducendo il moltiplicatore smorza efficacemente il processo di apprendimento, aumentando la possibilità di fermarsi al momento giusto, ma anche aumentando il tempo di esecuzione.
   Additive logistic regression

  La regressione additiva può essere applicata anche alla classificazione come la regressione lineare può. Ma sappiamo dalla sezione 4.6 che la regressione logistica supera la regressione lineare per la classificazione. Si scopre che un adattamento simile può essere fatto a modelli addizionali modificando il metodo di modellazione di stagne per eseguire la regressione logistica addizionale. Utilizzare la transizione logit per tradurre il problema di "probabilità di stima" in un problema di regressione, come abbiamo fatto nella sezione 4.6 e risolvere l'attività di regressione utilizzando un insieme di modelli - ad esempio, alberi di regressione - proprio come per la regressione degli additivi. Ad ogni fase, aggiungere il modello che massimizza la probabilità dei dati forniti dal classificatore dell'assemblea. Supponiamo che fj sia il modello di regressione j nel complesso e fj (a) è la sua predizione ad esempio a. Assumendo un problema a due categorie, utilizzare il modello addizionale Sfj (a) per ottenere una stima di probabilità per la prima classe:

 .....

  Questo assomiglia molto all'espressione utilizzata nella sezione 4.6 (pagina 121), tranne che qui viene abbreviata usando la notazione vettoriale per l'istanza a e la somma ponderata originale dei valori degli attributi viene sostituita da una somma di modelli arbitrariamente complessi di regressione f.


  La Figura 7.9 mostra la versione a due livelli dell'algoritmo LogitBoost, che esegue la regressione logistica addizionale e genera i singoli modelli fj. Qui yi è 1 per un'istanza nella prima classe e 0 per un'istanza nel secondo. In ogni iterazione questo algoritmo si adatta a un modello di regressione fj a una versione ponderata di


   Figure 7.9 Algorithm for additive logistic regression.


  Il set di dati originale basato su valori di classe dummy zi e pesi wi. Supponiamo che p (1 | a) sia calcolato usando i fj che sono stati costruiti nelle iterazioni precedenti. La derivazione di questo algoritmo è al di là dell'ambito di questo libro, ma può essere dimostrato che l'algoritmo massimizza la probabilità dei dati rispetto all'insieme se ogni modello fj viene determinato riducendo al minimo l'errore quadrato sul problema di regressione corrispondente. Infatti, se si utilizza la regressione lineare multipla per formare il fj, l'algoritmo converge al modello di regressione lineare-logistica di massima probabilità: è un'incarnazione del metodo di minore squares ripetutamente iterativamente menzionato nella sezione 4.6.

  Superficialmente, LogitBoost sembra abbastanza diverso da AdaBoost, ma i predittori che producono differiscono soprattutto perché il primo ottimizza la probabilità direttamente, mentre quest'ultima ottimizza una funzione di perdita esponenziale che può essere considerata come una approssimazione. Da una prospettiva pratica, la differenza è che LogitBoost utilizza un metodo di regressione come base di apprendimento mentre AdaBoost funziona con gli algoritmi di classificazione.
      Abbiamo mostrato solo la versione a due livelli di LogitBoost, ma l'algoritmo può essere generalizzato a problemi multiclasse. Come per la regressione degli additivi, il rischio di overfitting può essere ridotto riducendo le previsioni del singolo fj con un moltiplicatore predeterminato e utilizzando la convalida incrociata per determinare un numero appropriato di iterazioni.
   Option trees

  Baging, boosting e randomization tutti producono gruppi di classificatori. Ciò rende molto difficile analizzare quali tipi di informazioni sono state estratte dai dati. Sarebbe bello avere un unico modello con le stesse prestazioni predittive. Una possibilità è quella di generare un set di dati artificiali, campionando casualmente punti dallo spazio di istanza e assegnandoli le etichette di classe previste dal classificatore dell'assemblea e quindi imparare un albero di decisione o una regola impostata da questo nuovo set di dati. Per ottenere prestazioni similari predittive dall'albero dall'alloggiamento può essere richiesto un enorme set di dati, ma nel limite questa strategia dovrebbe essere in grado di replicare le prestazioni del "classificatore d'insieme", e certamente se "l'insieme stesso" consiste Di alberi decisionali.

  Un altro approccio è quello di derivare una singola struttura che possa rappresentare un insieme di classificatori in modo compatto. Ciò può essere fatto se l'insieme è costituito da alberi decisionali; Il risultato è chiamato un albero delle opzioni. Gli alberi di opzioni differiscono dagli alberi decisionali in quanto contengono due tipi di nodi: nodi di decisione e nodi di opzione. La Figura 7.10 mostra un semplice esempio per i dati meteo, con un solo nodo di opzione. Per classificare un'istanza, filtrarlo attraverso l'albero. Ad un nodo di decisione prendere solo uno dei rami, come al solito, ma in un nodo di opzione prendere tutti i rami. Ciò significa che l'istanza termina in più di una foglia, e le classificazioni ottenute da queste foglie devono in qualche modo essere combinate in una classificazione globale. Questo può essere fatto semplicemente votando, prendendo la votazione di maggioranza in un nodo di opzione per essere la previsione del nodo. In questo caso non ha senso avere nodi di opzione con solo due opzioni (come nella Figura 7.10) perché ci sarà solo una maggioranza se entrambi i rami sono d'accordo. Un'altra possibilità è quella di mediare le stime di probabilità ottenute dai diversi percorsi, utilizzando una media ponderata o un approccio Bayesiano più sofisticato.


   Figure 7.10 Simple option tree for the weather data.


  Gli alberi delle opzioni possono essere generati modificando un utente esistente di albero di decisione per creare un nodo di opzione se ci sono diverse divisioni che sembrano utili in base al loro guadagno di informazioni. Tutte le scelte all'interno di una certa tolleranza specificata dall'utente del meglio possono essere fatti in opzioni. Durante la potatura, l'errore di un nodo di opzione è l'errore medio delle sue opzioni.

  Un'altra possibilità è quella di far crescere un albero delle opzioni aggiungendo incrementalmente i nodi. Questo è comunemente fatto usando un algoritmo di amplificazione e gli alberi risultanti sono solitamente chiamati alberi di decisione alternati anziché alberi di opzione. In questo contesto i nodi di decisione vengono chiamati nodi di divisione e i nodi di opzione sono chiamati nodi di previsione. I nodi di previsione sono foglie se non sono stati aggiunti nodi di splitter. L'albero di decisione alternato standard si applica a problemi a due livelli e con ogni nodo di previsione viene associato un valore numerico positivo o negativo. Per ottenere una previsione per un'istanza, filtrare tutte le ramificazioni applicabili e riassumere i valori di tutti i nodi di previsione che si incontrano; Predire una classe o l'altra a seconda che la somma sia positiva o negativa.

  Un albero di esempio semplice per i dati meteo è mostrato in Figura 7.11, dove un valore positivo corrisponde alla classe play = no e negativo da giocare = si. Per classificare un'istanza con outlook = soleggiato, temperatura = caldo, umidità = normale, e vento = falso, filtrarlo verso le corrispondenti foglie, ottenendo i valori -0.255, 0.213, -0.430 e -0.331. La somma di questi valori è negativa; Quindi prevedere il gioco = yes. Gli alberi di decisione alternati hanno sempre un nodo di previsione alla radice, come in questo esempio.

 

 Figure 7.11 Alternating decision tree for the weather data.


  L'albero alternato viene coltivato ad esempio mediante un algoritmo di amplificazione, un algoritmo di amplificazione che impiega un principiante di base per la previsione numerica, come il metodo LogitBoost descritto in precedenza. Supponiamo che lo studente di base produce una sola regola congiuntiva in ogni amplificazione iterazione. Poi un albero di decisione alternato può essere generato semplicemente aggiungendo ciascuna regola all'albero. I punteggi numerici associati ai nodi di previsione vengono ottenuti dalle regole. Tuttavia, l'albero risultante sarebbe cresciuto molto rapidamente perché le regole di diverse iterazioni di potenziamento sono probabilmente diverse. Quindi, gli algoritmi di apprendimento per gli alberi decisionali alternati considerano solo quelle regole che estendono uno dei percorsi esistenti nell'albero aggiungendo un nodo di splitter e due nodi di previsione corrispondenti (supponendo le divisioni binarie). Nella versione standard dell'algoritmo, ogni posizione possibile nell'albero è considerata per l'aggiunta e un nodo viene aggiunto in base a una misura di prestazione che dipende dal particolare algoritmo di boosting impiegato. Tuttavia, l'euristica può essere utilizzata anziché una ricerca esaustiva per accelerare il processo di apprendimento.
   Logistic model trees

  Gli alberi di opzioni e gli alberi alternati producono prestazioni di classificazione molto buona basate su una singola struttura, ma possono essere difficili da interpretare quando esistono molti nodi di opzioni perché diventa difficile vedere come viene derivata una particolare previsione. Tuttavia, si scopre che il potenziamento può anche essere utilizzato per costruire alberi decisionali molto efficaci che non includono alcuna opzione a tutti. Ad esempio, l'algoritmo LogitBoost è stato utilizzato per indurre gli alberi con modelli di regressione logistica lineare alle foglie. Questi sono chiamati alberi di modello logistico e vengono interpretati allo stesso modo degli alberi di modello per la regressione descritta nella sezione 6.5

   LogitBoost esegue la regressione logistica addizionale. Supponiamo che ogni iterazione dell'algoritmo di boosting sia adatta a una semplice funzione di regressione passando attraverso tutti gli attributi, trovando la semplice funzione di regressione con l'errore più piccolo e aggiungendolo nel modello additivo. Se l'algoritmo LogitBoost viene eseguito fino alla convergenza, il risultato è un modello di regressione multiplo-logistica di massima probabilità. Tuttavia, per ottenere prestazioni ottimali sui dati futuri, di solito non è necessario aspettare la convergenza - e per farlo è spesso dannoso. Un numero appropriato di incrementi di iterazioni può essere determinato stimando le prestazioni previste per un determinato numero di iterazioni utilizzando la convalida incrociata e arrestando il processo quando la prestazione cessa di aumentare.

  Una semplice estensione di questo algoritmo porta ad alberi di modelli logistici. Il processo di amplificazione termina quando non esiste un'altra struttura nei dati che possono essere modellati utilizzando una funzione di regressione logistica lineare. Tuttavia, può essere ancora una struttura che i modelli lineari possono adattarsi se l'attenzione è limitata a sottotitoli dei dati ottenuti, ad esempio, da un criterio di albero decisionale standard come il guadagno di informazioni. Quindi, una volta che nessun ulteriore miglioramento può essere ottenuto aggiungendo più semplici modelli lineari, i dati vengono divisi e l'incremento viene ripreso separatamente in ciascun sottoinsieme. Questo processo prende il modello logistico generato finora e lo raffina separatamente per i dati in ogni sottoinsieme. Ancora una volta, la convalida incrociata viene eseguita in ogni sottoinsieme per determinare un numero appropriato di iterazioni da eseguire in quel sottoinsieme.

  Il processo viene applicato ricorsivamente fino a diventare troppo piccoli. L'albero risultante sarà sicuramente inutilizzabile i dati formativi e uno dei metodi standard di apprendimento degli alberi decisionali può essere utilizzato per "tagliarlo". Gli esperimenti indicano che l'operazione di potatura è molto importante. Utilizzando una strategia che sceglie la dimensione dell'albero giusto utilizzando la convalida incrociata, l'algoritmo produce alberi piccoli ma molto precisi con modelli logistici lineari alle foglie.
   Stacking

  Generalizzazione impilata o impilamento per breve, è un modo diverso di combinare più modelli. Sebbene sia sviluppato qualche anno fa, è meno ampiamente usato che l'imbottigliamento e il potenziamento, in parte perché è difficile analizzare teoricamente e in parte perché non esiste un modo migliore per farlo, l'idea di base può essere applicata in molte varianti diverse.

  A differenza dell'invasatura e del potenziamento, l'impilamento non viene normalmente utilizzato per combinare modelli dello stesso tipo, ad esempio un insieme di alberi decisionali. Viene invece applicato ai modelli costruiti da diversi algoritmi di apprendimento. Supponi di avere un induttore di albero decisionale, un alunno Naïve Bayes e un metodo di apprendimento basato su istanze e si desidera formare un classificatore per un dato set di dati. La procedura consueta sarebbe quella di stimare l'errore previsto di ciascun algoritmo mediante la convalida incrociata e di scegliere quello migliore per formare un modello per la previsione dei dati futuri. Ma non c'è un modo migliore? Con tre algoritmi di apprendimento disponibili, non possiamo utilizzare tutti e tre per la previsione e combinare le uscite insieme?

  Utilizzare tutti e tre per la previsione e combinare le uscite insieme? Un modo per combinare le uscite è quello di voto - lo stesso meccanismo utilizzato per l'imbottigliamento. Tuttavia, la votazione (non ponderata) ha senso solo se i programmi di apprendimento eseguono comparabilmente bene. Se due dei tre classificatori fanno previsioni grossolanamente sbagliate, saremo in difficoltà! Invece, l'impilamento introduce il concetto di un metalloario, che sostituisce la procedura di voto. Il problema con il voto è che non è chiaro quale classifiere di fiducia. L'impilamento cerca di capire quali classificatori sono quelli affidabili, utilizzando un altro algoritmo di apprendimento - il metalearner - per scoprire come combinare meglio l'output dei discenti di base.

  L'ingresso al metamodello - chiamato anche il livello-1 - sono le previsioni dei modelli di base o dei modelli di livello 0. Un'istanza di livello 1 ha altretanti attributi in quanto ci sono studenti di livello 0 e i valori degli attributi forniscono le previsioni di questi discenti sull'istanza livello-0 corrispondente. Quando il pilota impilato viene utilizzato per la classificazione, un'istanza viene prima inserita nei modelli di livello 0 e ciascuno indovina un valore di classe. Queste asserzioni vengono alimentate nel modello di livello 1, che li unisce nella predizione finale.

  Resta il problema di addestrare il livello-1 allievo. Per fare questo, dobbiamo trovare un modo per trasformare i dati di formazione livello-0 (usati per formare i livelli di 0 livello) nei dati formativi di livello 1 (utilizzati per addestrare il livello 1). Questo sembra semplice: ogni modello di livello 0 classifichi un'istanza di addestramento e attribuisca alle loro previsioni il valore reale della classe dell'istanza per ottenere un'istanza di formazione livello-1. Purtroppo, questo non funziona bene. Permetterebbe che le regole venissero apprese come credono sempre l'uscita del classificatore A e ignorano B e C. Questa regola potrebbe essere appropriata per determinati classificatori di base A, B e C; Se è così, sarà probabilmente appreso. Ma solo perché sembra opportuno sui dati di formazione non significa necessariamente che funziona bene sui dati di prova perché inevitabilmente imparerà a preferire i classificatori che sovrascrivono i dati di formazione su quelli che prendono decisioni più realistiche.

  

Di conseguenza, l'impilamento non modifica semplicemente i dati di formazione livello-0 in dati di livello 1 in questo modo. Ricordiamo dal capitolo 5 che ci sono metodi migliori per valutare la prestazione di un classificatore che utilizzare l'errore sul set di formazione. Uno è quello di tenere alcuni istanze e li usa per una valutazione indipendente. Applicando questo allo stacking, riserviamo alcune istanze per formare i dati di addestramento per il livello 1 e generare classificatori di livello 0 dai dati rimanenti. Una volta che i classificatori di livello 0 sono stati costruiti, vengono utilizzati per classificare le istanze nel set di holdout, formando i dati di formazione livello-1 come descritto in precedenza. Poiché i classificatori di livello 0 non sono stati addestrati in questi casi, le loro previsioni sono imparziali; Pertanto i dati di formazione del livello 1 riflettono accuratamente la reale performance degli algoritmi di apprendimento livello-0. Una volta che i dati di livello 1 sono stati generati da questa procedura di tenuta, i discenti di livello 0 possono essere reapplicati per generare classificatori dal set completo di formazione, facendo un uso leggermente migliore dei dati e portando a migliori previsioni.
   Il metodo di holdout inevitabilmente priva il modello livello-1 di alcuni dei dati formativi. Nel capitolo 5, la convalida incrociata è stata introdotta come mezzo per eludere questo problema per la stima degli errori. Questo può essere applicato in combinazione con l'impilamento eseguendo una convalida incrociata per ogni livello-0 studente. Ogni istanza dei dati di addestramento avviene esattamente in una delle pieghe di prova della convalida incrociata e le previsioni degli induttori di livello 0 costruite dalla corrispondente piega di formazione vengono utilizzati per costruire un'istanza di formazione livello-1 da essa. Questo genera un'istanza di formazione livello-1 per ogni istanza di livello-0. Naturalmente, è lento perché un classificatore di livello 0 deve essere addestrato per ogni piega della convalida incrociata, ma consente al classificatore livello-1 di utilizzare pienamente i dati di formazione.

   Dato un'istanza di prova, la maggior parte dei metodi di apprendimento è in grado di produrre probabilità per ogni etichetta di classe anziché fare una singola predizione categorica. Questo può essere sfruttato per migliorare le prestazioni dello stacking utilizzando le probabilità di formare i dati del livello-1. L'unica differenza alla procedura standard è che ogni attributo nominale livello-1, che rappresenta la classe prevista da un livello-0, viene sostituito da diversi attributi numerici, ognuno dei quali rappresenta una probabilità di classe prodotta dal livello-0 apprendente. In altre parole, il numero di attributi nei dati di livello 1 viene moltiplicato per il numero di classi. Questa procedura ha il vantaggio che il livello-1 apprendente è riservato alla fiducia che ogni livello-0 studente associati alle sue previsioni, ampliando così la comunicazione tra i due livelli di apprendimento.

   Rimane una domanda in sospeso: quali algoritmi sono adatti al livello 1? In linea di principio, è possibile applicare qualsiasi schema di apprendimento. Tuttavia, poiché la maggior parte dei lavori è già fatta dai discenti di livello 0, il classificatore di livello 1 è fondamentalmente solo un arbitro e ha senso scegliere un algoritmo piuttosto semplice per questo scopo. Secondo le parole di David Wolpert, inventore di impilamento, è ragionevole che i "generalizzatori di livello 1" relativamente globali e lisci dovrebbero funzionare bene. Semplice modelli lineari o alberi con modelli lineari alle foglie di solito funzionano bene.
   L'impilatura può essere applicata anche alla previsione numerica. In questo caso, i modelli livello-0 e il modello livello-1 prevedono valori numerici. Il meccanismo di base rimane lo stesso; L'unica differenza sta nella natura dei dati del livello-1. Nel caso numerico, ogni attributo level-1 rappresenta la previsione numerica effettuata da uno dei modelli di livello 0 e invece di un valore di classe il valore di destinazione numerico è associato alle istanze di formazione livello-1.
    Error-correcting output codes

  I codici di output di correzione degli errori sono una tecnica per migliorare le prestazioni degli algoritmi di classificazione nei problemi di apprendimento multiclass. Ricordiamo dal capitolo 6 che alcuni algoritmi di apprendimento - ad esempio, vettori standard di supporto vettoriale - funzionano solo con problemi a due livelli. Per applicare tali algoritmi a set di dati multiclass, il set di dati viene scomposto in più problemi indipendenti a due classi, l'algoritmo viene eseguito su ciascuno e le uscite dei classificatori risultanti vengono combinate. I codici di output di correzione degli errori sono un metodo per sfruttare al meglio questa trasformazione. Infatti, il metodo funziona così bene che spesso è vantaggioso applicarlo anche quando l'algoritmo di apprendimento può gestire direttamente i set di dati multiclass.

  Nella Sezione 4.6 (pagina 123) abbiamo imparato a trasformare un set di dati multiclass in più di due classi. Per ogni classe viene generato un set di dati contenente una copia di ogni istanza nei dati originali, ma con un valore di classe modificato. Se l'istanza ha la classe associata al set di dati corrispondente, viene contrassegnato sì; Altrimenti no. Quindi i classificatori sono costruiti per ognuno di questi set di dati binari, i classificatori che emettono una figura di fiducia con le loro previsioni, ad esempio, la probabilità stimata che la classe è sì. Durante la classificazione viene inserita un'istanza di prova in ogni classificatore binario e la classe finale è quella associata al classificatore che prevede sì in modo più sicuro. Naturalmente, questo metodo è sensibile all'accuratezza delle figure di fiducia prodotte dai classificatori: se alcuni classificatori hanno un parere esagerato delle proprie previsioni, il risultato complessivo "soffrirà".

  Si consideri un problema multiclass con le quattro classi a, b, c e d. La trasformazione può essere visualizzata come mostrato nella Tabella 7.1 (a), dove sì e no vengono mappati rispettivamente a 1 e 0. Ciascuno dei valori di classe originali viene convertito in una parola di codice a 4 bit, 1 bit per classe, ei quattro classificatori prevedono i bit in modo indipendente. Interpretando il processo di classificazione in termini di queste parole di codice, gli errori si verificano quando il bit binario errato riceve la confidenza più alta.

  Tuttavia, non dobbiamo utilizzare le parole del codice specifiche mostrate. Infatti, non vi è alcuna ragione per cui ogni classe deve essere rappresentata da 4 bit. Guardate invece il codice della tabella 7.1 (b), dove le classi sono rappresentate da 7 bit. Quando viene applicato ad un set di dati, è necessario costruire sette classificatori invece di quattro. Per vedere cosa potrebbe acquistare, considera la classificazione di un'istanza particolare. Supponiamo che appartiene alla classe a, e che le previsioni dei singoli classificatori sono 1 0 1 1 1 1 (rispettivamente). Ovviamente, confrontando questa parola di codice con quelle della Tabella 7.1 (b), il secondo classificatore ha commesso un errore: prevedeva 0 anziché 1, anziché sì. Tuttavia, confrontando i bit previsti con la parola di codice associata a ciascuna classe, l'istanza è chiaramente più vicino a quella di qualsiasi altra classe. Ciò può essere quantificato dal numero di bit da modificare per convertire la parola di codice prevista in quelle di Tabella 7.1 (b): la distanza Hamming o la discrepanza tra le stringhe dei bit è 1, 3, 3 e 5 Rispettivamente le classi a, b, c e d. Possiamo tranquillamente concludere che il secondo classificatore ha commesso un errore e ha identificato correttamente come una vera classe di istanza.

   Lo stesso tipo di correzione degli errori non è possibile con le parole di codice della Tabella 7.1 (a), perché ogni stringa predittiva di 4 bit diversi da queste quattro parole a 4 bit ha la stessa distanza di almeno due di esse. I codici di output non sono "correzione degli errori".Che cosa determina se un codice è corretto o meno? Si consideri la distanza Hamming tra le parole di codice che rappresentano classi diverse. Il numero di errori che possono essere corretti dipende dalla distanza minima tra qualsiasi coppia di parole di codice, ad esempio d. Il codice è in grado di correggere fino a (d - 1) / 2 errori a 1 bit, perché se questo numero di bit della parola di codice corretta è flipped, sarà ancora il più vicino e sarà quindi identificato correttamente. Nella tabella 7.1 (a) la distanza Hamming per ogni coppia di parole di codice è 2. Quindi la distanza minima d è anche 2 e possiamo correggere non più di 0 errori! Tuttavia, nel codice della tabella 7.1 (b) la distanza minima è 4 (infatti, la distanza è 4 per tutte le coppie). Ciò significa che è garantito per correggere errori a 1 bit.

   Abbiamo identificato una proprietà di un buon codice di correzione degli errori: le parole di codice devono essere ben separate in termini di distanza Hamming. Poiché comprendono le righe della tabella di codice, questa proprietà viene chiamata separazione di righe. Esiste un secondo requisito che occorre soddisfare un buon codice di correzione degli errori: la separazione delle colonne. La distanza Hamming tra ogni coppia di colonne deve essere grande, come deve essere la distanza tra ogni colonna e il complemento di ogni altra colonna. Nella tabella 7.1 (b), le sette colonne sono separate da un altro (e dai loro complementi) da almeno un bit.
    La separazione delle colonne è necessaria perché se due colonne sono identiche (o se è un complemento di un altro), i corrispondenti classificatori faranno gli stessi errori. La correzione dell'errore è indebolita se gli errori sono correlati in altre parole, se molte posizioni di bit sono simultaneamente non corrette. Maggiore è la distanza tra le colonne, più errori sono probabili essere corretti.

   Con meno di quattro classi è impossibile costruire un codice di correzione degli errori efficace, poiché non è possibile ottenere una buona separazione delle righe e una buona separazione di colonne contemporaneamente. Ad esempio, con tre classi ci sono solo otto colonne possibili (23), quattro dei quali sono complementi degli altri quattro. Inoltre, le colonne con tutti gli zeri o tutti non forniscono alcuna discriminazione. Ciò lascia solo tre colonne possibili, e il codice risultante non è affatto un errore di correzione. (Infatti, è la codifica standard "una per classe").

    Se ci sono poche classi, è possibile costruire un codice esauriente di correzione degli errori, come quello della tabella 7.1 (b). In un codice esaustivo per le classi k, le colonne comprendono tutte le possibili stringhe di k-bit, ad eccezione dei complementi e delle banali tutte le stringhe zero o tutte. Ogni parola di codice contiene 2k-1 - 1 bit. Il codice è costruito come segue: la parola di codice per la prima classe è costituita da tutti; Che per la seconda classe ha zeri 2k-2 seguiti da 2k-2-1; Il terzo ha 2k-3 zeri seguiti da 2k-3 quelli seguiti da zero di 2k-3 seguiti da 2k-3 - 1; e così via. La parola di codice ith è costituita da una sequenza alternata di zero e di quelli 2k-i, l'ultima corsa è una breve.
     Con più classi, i codici esaustivi sono impossibili perché il numero di colonne aumenta in modo esponenziale e troppi classificatori devono essere costruiti. In questo caso vengono utilizzati metodi più sofisticati che possono costruire un codice con buone proprietà di correzione degli errori da un numero minore di colonne.

  I codici di output di correzione degli errori non funzionano per gli algoritmi di apprendimento locale come i partecipanti basati sull'istanza, che prevedono la classe di un'istanza guardando istanze di formazione vicine. Nel caso di un classificatore di prossimità più vicino, tutti i bit di output sarebbero stati predetti utilizzando la stessa istanza di formazione. Il problema può essere eluso utilizzando diversi sottotitoli di attributo per predire ogni bit di output, decorrelating le previsioni.
     Utilizzo di dati non contrassegnati - Using unlabeled data

  Quando abbiamo introdotto il processo di apprendimento macchina nel Capitolo 2 abbiamo tracciato una netta distinzione tra l'apprendimento-classificazione e il clustering supervisionati e non supervisionati. Recentemente i ricercatori hanno iniziato ad esplorare il territorio tra i due, talvolta chiamati apprendimento semiservizzato, in cui l'obiettivo è la classificazione, ma l'input contiene sia i dati non etichettati che quelli contrassegnati. Non puoi classificare senza dati etichettati, naturalmente, perché solo le etichette indicano le classi. Ma a volte è attraente aumentare una piccola quantità di dati etichettati con una grande quantità di dati non contrassegnati. Risulta che i dati non contrassegnati possono aiutare a imparare le classi. Come può essere questo?

   Innanzitutto, perché lo desideri? Molte situazioni presentano enormi volumi di dati grezzi, ma assegnare classi è costoso perché richiede una visione umana. L'estrazione del testo fornisce alcuni esempi classici. Supponiamo di classificare le pagine Web in gruppi predefiniti. In un ambito accademico potresti essere interessato alle pagine del docente, alle pagine di studenti laureati, alle pagine di informazione sui corsi, alle pagine del gruppo di ricerca e alle pagine dei reparti. È possibile scaricare facilmente migliaia o milioni di pagine rilevanti da siti web universitari. Ma l'etichettatura dei dati formativi è un laborioso processo manuale. Oppure supponiamo che il tuo lavoro è quello di utilizzare l'apprendimento macchina per individuare i nomi nel testo, distinguendo tra nomi personali, nomi aziendali e nomi di località. È possibile scaricare facilmente megabyte o gigabyte di testo, ma fare questo in dati di formazione selezionando i nomi e classificandoli può essere eseguito solo manualmente. Catalogando articoli di notizie, ordinando la posta elettronica, imparando gli interessi di lettura degli utenti, le applicazioni 'sono legioni'. Lasciando il testo a parte, supponi che vuoi imparare a riconoscere alcune persone famose nelle notizie televisive. È possibile registrare facilmente centinaia o migliaia di ore di notizie, ma l'etichettatura è ancora manuale. In uno qualsiasi di questi scenari sarebbe estremamente interessante poter sfruttare un'ampia gamma di dati non contrassegnati per ottenere prestazioni eccellenti da pochi esempi etichettati, in particolare se sei stato lo studente che ha dovuto fare l'etichettatura!
   Clustering for classification

  Come utilizzare i dati non etichettati per migliorare la classificazione? Ecco una semplice idea. Usa Bayes Naïve per apprendere le classi da un piccolo set di dati etichettato e quindi estenderlo ad un grande set di dati non etichettato utilizzando l'algoritmo di clustering iterativo EM (aspettativa-massimizzazione) di Sezione 6.6. La procedura è questa. Innanzitutto, formi un classificatore utilizzando i dati etichettati. In secondo luogo, applicarlo ai dati non etichettati per etichettarlo con probabilità di classe (il passo "aspettativa"). In terzo luogo, treni un nuovo classificatore che utilizza le etichette per tutti i dati (la "massimizzazione"). Quarto, iterare fino alla convergenza. Potresti pensare a questo come clustering iterativo, in cui i punti di partenza e le etichette cluster vengono raccolte dai dati etichettati. La procedura EM garantisce di trovare parametri di modello che hanno ogni probabilità uguale o maggiore in ogni iterazione. La questione chiave, che può essere risolta solo empiricamente, è se queste stime di parametri di maggiore probabilità migliorino la precisione della classificazione.

  Intuitivamente, questo potrebbe funzionare bene. Considera la classificazione dei documenti. Alcune frasi sono indicative delle classi. Alcuni si verificano in documenti etichettati, mentre altri si verificano solo in quelli non etichettati. Ma ci sono probabilmente alcuni documenti che contengono entrambi, e la procedura EM li usa per generalizzare il modello appreso per utilizzare frasi che non appaiono nel dataset di etichetta. Ad esempio, sia il supervisore che l'argomento di dottorato possono indicare la home page dello studente universitario. Supponiamo che solo la prima frase si verifichi nei documenti etichettati. EM iterativamente generalizza il modello per classificare correttamente i documenti che contengono solo questi ultimi.

   Questo potrebbe funzionare con qualsiasi classificatore e qualsiasi algoritmo di clustering iterativo. Ma è fondamentalmente una procedura di bootstrap, e si deve fare attenzione a garantire che il ciclo di feedback è positivo. Utilizzando probabilità piuttosto che decisioni difficili sembra utile perché consente alla procedura di convergere lentamente invece di saltare a conclusioni che possono essere sbagliate. Naïve Bayes e la procedura probabilistica di EM descritta in Sezione 6.6 sono particolarmente opportune scelte perché condividono la stessa ipotesi fondamentale: l'indipendenza tra gli attributi o, più precisamente, l'indipendenza condizionale tra gli attributi attribuiti alla classe.

  Naturalmente, l'assunzione dell'indipendenza è universalmente violata. Anche il nostro piccolo esempio usava l'argomento PhD a due parole, mentre le implementazioni effettive avrebbero probabilmente usato singole parole come attributi e l'esempio sarebbe stato molto meno convincente se avessimo sostituito uno dei singoli termini del Dottorato o argomento. La frase di dottorandi è probabilmente più indicativa di facoltà rispetto alle domande di studenti universitari; L'argomento della ricerca di frasi è probabilmente meno discriminante. È proprio il fatto che il dottorato di ricerca e l'argomento non sono condizionatamente indipendenti a causa della classe che fa funzionare l'esempio: è la loro combinazione che caratterizza le pagine dei laureati.Tuttavia, il collegamento di Naïve Bayes e EM in questo modo funziona bene nel campo della classificazione dei documenti. In un particolare compito di classificazione ha raggiunto le prestazioni di un apprendente tradizionale utilizzando meno di un terzo delle istanze di formazione etichettate, nonché cinque volte più etichettati. Questo è un buon compromesso quando le istanze etichettate sono costose ma quelle non marcate sono praticamente gratuite. Con un numero ridotto di documenti etichettati, la precisione della classificazione può essere migliorata in modo drammatico incorporando molti non etichettati.

  Sono state dimostrate due raffinatezze alla procedura per migliorare le prestazioni. Il primo è motivato da prove sperimentali che, quando ci sono molti documenti etichettati, l'incorporazione di dati non contrassegnati può ridurre piuttosto che aumentare l'accuratezza. I dati contrassegnati dalla mano sono (o dovrebbero essere) intrinsecamente meno rumorosi di quelli automaticamente etichettati. La soluzione è introdurre un parametro di ponderazione che riduce il contributo dei dati non contrassegnati. Questo può essere incorporato nella fase di massimizzazione di EM massimizzando la probabilità ponderata delle istanze etichettate e non etichettate. Quando il parametro è vicino a zero, i documenti non etichettati hanno poca influenza sulla forma della superficie di salita in collina di EM; Quando vicino ad uno, l'algoritmo ritorna alla versione originale in cui la superficie è ugualmente interessata da entrambi i tipi di documento.

   La seconda raffinatezza consiste nel permettere ad ogni classe di avere diversi cluster. Come spiegato nella sezione 6.6, l'algoritmo di clustering EM presuppone che i dati siano generati in modo casuale da una miscela di diverse distribuzioni di probabilità, una per cluster. Fino ad ora è stata presa in considerazione una corrispondenza tra i componenti e le classi della miscela. In molte circostanze questo è irrealistico, inclusa la classificazione dei documenti, perché la maggior parte dei documenti affronta più argomenti. Con diversi cluster per classe, ciascun documento etichettato viene assegnato in modo casuale a ciascuno dei suoi componenti in modo probabilistico. La fase di massimizzazione dell'algoritmo EM rimane come prima, ma il passaggio di aspettativa viene modificato per non solo etichettare probabilmente ogni esempio con le classi, ma assegnarlo probabilmente ai componenti all'interno della classe. Il numero di cluster per classe è un parametro che dipende dal dominio e può essere impostato tramite la convalida incrociata.
    Co-training

  Un'altra situazione in cui i dati non contrassegnati possono migliorare le prestazioni della classificazione è quando ci sono due prospettive diverse e indipendenti sull'attività di classificazione. L'esempio classico riporta ancora documenti, questa volta i documenti Web, in cui le due prospettive sono il contenuto di una pagina Web ei collegamenti ad essa da altre pagine. Queste due prospettive sono ben note per essere utili e diverse: i motori di ricerca Web di successo capitalizzano su entrambi, utilizzando ricette segrete. Il testo che etichette un collegamento ad un'altra pagina Web dà un'idea rivelatrice su come si tratta di questa pagina, forse anche più rivelatrice del contenuto personale della pagina, in particolare se il collegamento è indipendente. Intuitamente, un collegamento denominato il mio consulente è una prova forte che la pagina di destinazione è una home page di un membro del docente.

   L'idea, chiamata co-formazione, è questo. Dati alcuni esempi etichettati, innanzitutto imparare un modello diverso per ogni prospettiva - in questo caso un modello basato su contenuti e basato su un collegamento ipertestuale. Quindi utilizzare ciascuno di essi separatamente per etichettare gli esempi non etichettati. Per ogni modello, seleziona l'esempio più etichette con fiducia come positivo e quello con cui confida con certezza l'etichetta come negativa, e aggiungi questi al pool di esempi etichettati. Meglio ancora, mantenere il rapporto degli esempi positivi e negativi nella piscina etichettata scegliendo di più di un tipo rispetto all'altro. In entrambi i casi, ripetere l'intera procedura, addestrando entrambi i modelli sulla serie aumentata di esempi etichettati, finché la piscina non etichettata viene esaurita.

   Ci sono alcune prove sperimentali, usando Naïve Bayes in tutto come il discente, che questa procedura di bootstrapping supera quella che utilizza tutte le funzionalità di entrambe le prospettive per imparare un singolo modello dai dati etichettati. Essa si basa su due viste diverse di un'istanza che sono ridondanti ma non completamente correlate. Sono stati proposti vari domini, da celebrità di notizie in televisione newscast utilizzando video e audio separatamente a robot mobili con visione, sonar e sensori di gamma. L'indipendenza dei punti di vista riduce la probabilità che entrambe le ipotesi concordino su un'etichetta errata.
      EM and co-training

   Sui set di dati con due set di funzionalità veramente indipendenti, gli esperimenti hanno dimostrato che la co-formazione offre risultati migliori rispetto all'utilizzo di EM come descritto in precedenza. Ancora migliori prestazioni possono essere raggiunte combinando i due in una versione modificata di co-training chiamata co-EM. Il co-formazione tira due classificatori che rappresentano diverse prospettive A e B e usa entrambi per aggiungere nuovi esempi al pool di formazione scegliendo tutti gli esempi non etichettati che classificano in modo più positivo o negativo. I nuovi esempi sono pochi in numero e determinati etichettati. Co-EM, d'altra parte, traina prospettiva A sui dati etichettati e lo usa per etichettare probabilmente tutti i dati non etichettati. Successivamente esso addestra il classificatore B sia sui dati etichettati che sui dati non contrassegnati con le etichette tentativi del classificatore A e quindi ripamera probabilmente tutti i dati da utilizzare dal classificatore A. Il processo si estrae finché i convertitori di classificazione non convergono. Questa procedura sembrerebbe eseguire costantemente meglio della co-formazione perché non si impegna alle etichette di classe generate dai classificatori A e B ma piuttosto reimpira le loro probabilità ad ogni iterazione.

   La gamma di applicabilità del co-EM, come la co-formazione, è ancora limitata dal requisito di molteplici prospettive indipendenti. Ma ci sono alcune prove sperimentali che suggeriscono che anche quando non esiste una naturale separazione delle caratteristiche in prospettive indipendenti, i vantaggi possono essere ottenuti realizzando una tale suddivisione e utilizzando co-formazione - o, meglio ancora, co-EM - sui dati split . Questo sembra funzionare anche quando la divisione è fatta casuale; Le prestazioni potrebbero essere sicuramente migliorate progettando la suddivisione in modo che i set di funzionalità siano al massimo indipendenti. Perché questo lavoro? I ricercatori hanno ipotizzato che questi algoritmi riescano in parte perché la divisione li rende più robusti per le ipotesi che i loro classificatori sottostanti fanno.

   Non vi è alcuna ragione particolare per limitare il classificatore di base a Naïve Bayes. Le macchine vettoriali di supporto rappresentano probabilmente la tecnologia di maggior successo per la categorizzazione dei testi oggi. Tuttavia, per l'iterazione EM è necessario che il classificatore etichettare i dati probabilisticamente; Deve anche essere in grado di utilizzare esempi probabilmente ponderati per la formazione. Le macchine vettoriali di supporto possono essere facilmente adattate per fare entrambi. Abbiamo spiegato come adattare gli algoritmi di apprendimento per affrontare le istanze ponderate nella sezione 6.5 sotto la regressione lineare ponderata localmente (pagina 252). Un modo per ottenere le stime di probabilità dalle macchine vettoriali di supporto è quello di adattare un modello logistico unidimensionale all'uscita, effettivamente eseguendo la regressione logistica come descritto nella sezione 4.6 sull'output. Eccellenti risultati sono stati segnalati per la classificazione di testo usando co-EM con il classificatore di macchine vettoriali di supporto (SVM). Essa supera le altre varianti di SVM e sembra abbastanza robusta per diverse proporzioni di dati etichettati e non etichettati.
    Le idee di co-formazione e EM - e in particolare la loro combinazione nell'algoritmo co-EM - sono interessanti, provocatorie e hanno un potenziale impressionante. Ma ciò che li fa funzionare è ancora controverso e poco compreso. Queste tecniche sono oggetto di ricerca attuale: non sono ancora entrate nel mainstream di apprendimento automatico e sono state sfruttate per la pratica data mining.
   Letture

  La selezione degli attributi, sotto la selezione funzionalità di termini, è stata studiata nel campo del riconoscimento dei modelli per decenni. L'eliminazione all'indietro, ad esempio, è stata introdotta nei primi anni '60 (Marill e Green 1963). Kittler (1978) analizza gli algoritmi di selezione delle funzioni che sono stati sviluppati per il riconoscimento del pattern. Miglior prima ricerca e algoritmi genetici sono tecniche standard di intelligenza artificiale (Winston 1992, Goldberg 1989).

  Gli esperimenti che mostrano le prestazioni degli studenti degli alberi decisionali che si deteriorano quando vengono aggiunti nuovi attributi sono riportati da John (1997), che fornisce una bella spiegazione della selezione degli attributi. L'idea di trovare il più piccolo set di attributi che intaglia i casi in modo univoco è da Almuallin e Dietterich (1991, 1992) ed è stato ulteriormente sviluppato da Liu e Setiono (1996). Kibler e Aha (1987) e Cardie (1993) studiarono entrambi l'utilizzo di algoritmi ad alberi decisionali per identificare le caratteristiche per l'apprendimento più vicino; Holmes e NevillManning (1995) hanno usato 1R per ordinare le funzioni per la selezione. Kira e Rendell (1992) hanno utilizzato metodi basati su istanze per selezionare le funzionalità, portando ad uno schema denominato RELIEF per l'eliminazione ricorsiva delle funzioni. Gilad-Bachrach et al. (2004) mostrano come questo schema può essere modificato per funzionare meglio con gli attributi ridondanti. Il metodo di selezione delle funzionalità basato sulla correlazione è stato sviluppato da Hall (2000).
  L'uso di metodi di wrapper per la selezione delle funzioni è dovuto a John et al. (1994) e Kohavi e John (1997), e algoritmi genetici sono stati applicati all'interno di un framework wrapper da Vafaie e DeJong (1992) e Cherkauer e Shavlik (1996). Il metodo selettivo di apprendimento Naïve Bayes è dovuto a Langley e Sage (1994). Guyon et al. (2002) presentano e valutano lo schema di eliminazione delle funzioni ricorsive in combinazione con le macchine vettoriali di supporto. Il metodo della ricerca corsa è stato sviluppato da Moore e Lee (1994).

   Dougherty et al. (1995) forniscono un breve resoconto della discretizzazione supervisionata e non supervisionata, insieme a risultati sperimentali che confrontano il metodo basato su entropia con il binning di uguale larghezza e il metodo 1R. Frank e Witten (1999) descrivono l'effetto di utilizzare le informazioni di ordinazione in attributi discretizzati. La discretizzazione proporzionale del k-interval per Naïve Bayes è stata proposta da Yang e Webb (2001). Il metodo basato sulla entropia per la discretizzazione, compreso l'utilizzo del criterio di arresto MDL, è stato sviluppato da Fayyad e Irani (1993). Il metodo statistico bottom-up che utilizza il test c2 è dovuto a Kerber (1992) e la sua estensione a un livello di significatività determinata automaticamente è descritta da Liu e Setiono (1997). Fulton et al. (1995) approfondiscono l'uso della programmazione dinamica per la discretizzazione e derivano il tempo quadratico legato ad una funzione di impurità generale (ad esempio, entropia) e quella lineare per la discretizzazione basata sugli errori. L'esempio utilizzato per mostrare la debolezza della discretizzazione basata sugli errori è adattato da Kohavi e Sahami (1996), che sono stati i primi a identificare chiaramente questo fenomeno.
    L'analisi dei componenti principali è una tecnica standard che si può trovare nella maggior parte dei libri di testo delle statistiche. Fradkin e Madigan (2003) analizzano le prestazioni di proiezioni casuali. La metrica TF ¥ IDF è descritta da Witten et al. (1999b).
Gli esperimenti sull'uso del C4.5 per filtrare i propri dati formativi sono stati riportati da John (1995). L'approccio più conservatore di un filtro di consenso che coinvolge diversi algoritmi di apprendimento è stato studiato da Brodley e Friedl (1996). Rousseeuw e Leroy (1987) descrivono la rilevazione di outlier nella regressione statistica, compreso il metodo meno mediano di quadrati; Presentano anche i dati telefonici di Figura 7.6. È stato Quinlan (1986) che ha notato che la rimozione del rumore dagli attributi dell'istanza formativa può ridurre la prestazione di un classificatore su istanze di test simili, in particolare a livelli di rumore più alti.

   La combinazione di più modelli è un argomento di ricerca popolare nella ricerca di apprendimento macchina, con molte pubblicazioni correlate. Il termine bagging (per "bootstrap aggregating") è stato coniato da Breiman (1996b), che ha esaminato le proprietà di bagaglio teoricamente ed empiricamente per la classificazione e la previsione numerica. Domingos (1999) ha introdotto l'algoritmo MetaCost. La randomizzazione è stata valutata da Dietterich (2000) e confrontata con il saccheggio e il potenziamento. Bay (1999) suggerisce di utilizzare la randomizzazione per l'apprendimento degli ensemble con i classificatori più vicini. Foreste casuali sono state introdotte da Breiman (2001).
   Freund e Schapire (1996) hanno sviluppato l'algoritmo di amplificazione AdaBoost.M1 e hanno derivato i limiti teorici per la sua performance. Più tardi, hanno migliorato questi limiti utilizzando il concetto di margini (Freund e Schapire 1999). Drucker (1997) ha adattato AdaBoost.M1 per la previsione numerica. L'algoritmo LogitBoost è stato sviluppato da Friedman et al. (2000). Friedman (2001) descrive come far aumentare la resistenza in presenza di dati rumorosi. Domingos (1997) descrive come derivare un singolo modello interpretabile da un ensemble utilizzando esempi di addestramento artificiale. Gli alberi opzionali bayesiani sono stati introdotti da Buntine (1992) e la maggioranza dei voti è stata inserita negli alberi opzionali da Kohavi e Kunz (1997). Freund e Mason (1999) hanno introdotto alberi decisionali alternati; Gli esperimenti con gli alberi decisionali multiclass alternati sono stati segnalati da Holmes et al. (2002). Landwehr et al. (2003) ha sviluppato alberi di modello logistico utilizzando l'algoritmo LogitBoost.
  La generalizzazione impilata è nata da Wolpert (1992), che ha presentato l'idea nella letteratura della rete neurale e viene applicata alla previsione numerica di Breiman (1996a). Ting e Witten (1997a) confrontano empiricamente i diversi modelli di livello-1 e hanno scoperto che un semplice modello lineare esegue meglio; Hanno anche dimostrato il vantaggio di utilizzare le probabilità come dati di livello 1. È stata inoltre studiata una combinazione di impilamento e imbottigliamento (Ting e Witten 1997b).
  L'idea di utilizzare i codici di output di correzione degli errori per la classificazione ha ottenuto un'ampia accettazione dopo un lavoro di Dietterich e Bakiri (1995); Ricci e Aha (1998) hanno mostrato come applicare tali codici ai classificatori più vicini.

  Blum e Mitchell (1998) hanno promosso l'uso della co-formazione e hanno sviluppato un modello teorico per l'utilizzo di dati etichettati e non etichettati da diverse prospettive indipendenti. Nigam e Ghani (2000) hanno analizzato l'efficacia e l'applicabilità della co-formazione, correlandolo all'uso tradizionale di EM standard per riempire i valori mancanti. Essi hanno anche introdotto l'algoritmo co-EM. Nigam ed altri (2000) hanno esplorato esattamente come l'algoritmo di clustering EM possa utilizzare dati non attribuiti per migliorare un classificatore iniziale costruito da Naïve Bayes, come riportato nella sezione Clustering for classification. Fino a questo punto, la co-formazione e la co-EM sono stati applicati principalmente a piccoli problemi a due classi; Ghani (2002) ha usato errorcorrecting dei codici di output per affrontare situazioni multiclass con molte classi.
   Brefeld e Scheffer (2004) hanno esteso co-EM per utilizzare una macchina vettoriale di supporto piuttosto che Naïve Bayes. Seeger (2001) pone dubbi sul fatto che questi nuovi algoritmi dispongano davvero di offrire qualcosa di più di quelli tradizionali, correttamente utilizzati.
        Spostamento: Estensioni e Applicazioni

  L'apprendimento automatico è una nuova tecnologia per estrarre conoscenze dai dati, una tecnologia che molte persone stanno prendendo sul serio. Non vogliamo sovraccaricare. Il tipo di apprendimento delle macchine che conosciamo non riguarda i grossi problemi: visioni futuristiche di servi robotici autonomi, confusioni filosofiche di coscienza, questioni metafisiche del libero arbitrio, domande evoluzionarie o teologiche da dove viene l'intelligenza, dibattiti linguistici sull'apprendimento delle lingue, Teorie psicologiche dello sviluppo del bambino, o spiegazioni cognitive di quale intelligenza è e come funziona. Per noi, è molto più prosaico: l'apprendimento automatico riguarda algoritmi per l'inferire della struttura dai dati e dai modi per convalidare tale struttura. Questi algoritmi non sono abstrusi e complicati, ma non sono del tutto ovvie e banali.

  Guardando in avanti, la sfida principale è applicazioni. Le opportunità abbondano. Ovunque ci siano dati, le cose possono essere apprese da esso. Ogni volta che ci sono troppi dati per le persone a pompare su se stessi, la meccanica dell'apprendimento dovrà essere automatica. Ma l'ispirazione non sarà certamente automatica! Le applicazioni non provengono da programmi informatici, né da esperti di apprendimento macchina, né dai dati stessi, ma dalle persone che lavorano con i dati e dai problemi da cui nasce. Ecco perché abbiamo scritto questo libro e il sistema Weka descritto nella Parte II - per potenziare coloro che non sono esperti di apprendimento macchina per applicare queste tecniche ai problemi che sorgono nella vita quotidiana di lavoro. Le idee sono semplici. Gli algoritmi sono qui. Il resto è davvero su di te!
   Naturalmente, lo sviluppo della tecnologia non è certo finito. L'apprendimento automatico è un argomento di ricerca calda e nuove idee e tecniche emergono continuamente. Per dare un sapore alla portata e alla varietà dei fronti della ricerca, chiudiamo la parte I guardando alcune aree attuali nel mondo della data mining.
    Learning from massive datasets

  L'enorme proliferazione di banche dati molto grandi nelle aziende e nelle istituzioni scientifiche odierne rende necessario che gli algoritmi di apprendimento macchina operino su set di dati massicci. Due dimensioni separate diventano critiche quando ogni algoritmo viene applicato a set di dati molto grandi: spazio e tempo.

   Supponiamo che i dati siano così grandi che non possano essere tenuti nella memoria principale. Ciò non comporta alcuna difficoltà se il piano di apprendimento funziona in modo incrementale, elaborando un'istanza in un momento durante la generazione del modello. Un'istanza può essere letto dal file di input, il modello può essere aggiornato, l'istanza successiva può essere letto e così via, senza mai tenere più di un'istanza di formazione nella memoria principale. Normalmente, il modello risultante è piccolo rispetto alla dimensione del set di dati e la quantità di memoria disponibile non impone vincoli gravi. Il metodo Naïve Bayes è un eccellente esempio di questo tipo di algoritmo; Ci sono anche versioni incrementali di induttori di alberi decisionali e sistemi di apprendimento regole. Tuttavia, gli algoritmi incrementali per alcuni dei metodi di apprendimento descritti in questo libro non sono ancora stati sviluppati. Altri metodi, quali schemi basati su istanze di base e regressione localizzata, hanno bisogno di accedere a tutte le istanze di formazione a tempo di previsione. In questo caso, devono essere impiegati meccanismi sofisticati di caching e indicizzazione per mantenere solo le parti più frequentemente utilizzate di un set di dati in memoria e per consentire l'accesso rapido alle istanze rilevanti nel file.

   L'altra dimensione critica quando si applicano algoritmi di apprendimento a set di dati massivi è il tempo. Se il tempo di apprendimento non scala linearmente (o quasi linearmente) con il numero di istanze di addestramento, sarà infine impossibile elaborare set di dati molto grandi. In alcune applicazioni il numero di attributi è un fattore critico e solo i metodi che scendono linearmente nel numero di attributi sono accettabili. In alternativa, il tempo di previsione potrebbe essere il problema cruciale. Fortunatamente, ci sono molti algoritmi di apprendimento che scalano graziosamente durante la formazione e il test. Ad esempio, il tempo di formazione per Naïve Bayes è lineare sia nel numero di istanze che nel numero di attributi. Per gli induttori di albero di decisione dall'alto verso il basso abbiamo visto nel paragrafo 6.1 (pagine 196-198) che il tempo di addestramento è lineare nel numero di attributi e, se l'albero è uniformemente cespuglio, è log-lineare nel numero di istanze (se il sottotrezza Non viene utilizzato o, se è, con un ulteriore fattore di log).

   Quando un set di dati è troppo grande per un particolare algoritmo di apprendimento da applicare, esistono tre modi per rendere l'apprendimento possibile. Il primo è banale: invece di applicare lo schema al set completo, utilizzare solo un piccolo sottoinsieme per la formazione. Naturalmente, le informazioni vengono perse quando viene utilizzato il sottoamplificazione. Tuttavia, la perdita può essere trascurabile poiché la prestazione predittiva di un modello appreso spesso si appiattisce molto prima che tutti i dati di addestramento siano incorporati. Se questo è il caso, può essere facilmente verificato osservando le prestazioni del modello su un set di test di holdout per gruppi di formazione di dimensioni diverse.
   Questo tipo di comportamento, chiamato legge di diminuzione dei rendimenti, può sorgere perché il problema dell'apprendimento è semplice, in modo che un piccolo volume di dati di formazione è sufficiente per imparare un modello accurato. In alternativa, l'algoritmo di apprendimento potrebbe essere incapace di cogliere la struttura dettagliata del dominio sottostante. Questo è spesso osservato quando Naïve Bayes è impiegato in un dominio complesso: i dati addizionali di formazione potrebbero non migliorare le prestazioni del modello, mentre l'accuratezza dell'albero di decisione può continuare a salire. In questo caso, ovviamente, se la prestazione predittiva è l'obiettivo principale, devi passare all'algoritmo di apprendimento più complesso. Ma attenzione al sovraffollamento! Fare attenzione a non valutare le prestazioni dei dati formativi.

   La parallelazione è un altro modo per ridurre la complessità temporale dell'apprendimento. L'idea è di dividere il problema in parti più piccole, risolvere ciascuna con un processore separato e unire i risultati insieme. A tal fine, è necessario creare una versione parallela dell'algoritmo di apprendimento. Alcuni algoritmi si prestano naturalmente alla parallelizzazione. I metodi di prossimità più vicini, ad esempio, possono essere facilmente distribuiti tra più processori suddividendo i dati in più parti e consentendo a ciascun processore di trovare il prossimo più vicino nella sua parte del set di allenamento. Gli studenti degli alberi decisionali possono essere paralleli permettendo ad ogni processore di costruire un sottotrapo dell'albero completo. Bagging e impilamento (anche se non aumentando) sono naturalmente algoritmi paralleli. Tuttavia, la parallelizzazione è solo un rimedio parziale perché con un numero fisso di processori, la complessità del tempo asintotico dell'algoritmo non può essere migliorata.

   Un modo semplice per applicare qualsiasi algoritmo a un grande set di dati è quello di dividere i dati in pezzi di dimensioni limitate e apprendere i modelli separatamente per ciascuno, combinando il risultato utilizzando il voto o la media. A questo scopo può essere impiegato uno schema simile a quello di bagaglio o uno schema sequenziato. Il potenziamento ha il vantaggio che i nuovi pezzi possono essere ponderati in base ai classificatori appresi dai precedenti blocchi, trasferendo così la conoscenza tra i pezzi. In entrambi i casi il consumo di memoria aumenta linearmente con la dimensione del set di dati; Quindi è necessaria una forma di potatura per i set di dati molto grandi. Ciò può essere fatto mettendo da parte alcuni dati di convalida e solo aggiungendo un modello da un nuovo pezzo al classificatore di commissione se aumenta la prestazione del comitato sul set di convalida. Il set di convalida può anche essere utilizzato per identificare una dimensione del pezzo appropriata eseguendo il metodo con diverse dimensioni del pezzo in parallelo e monitorando le prestazioni sul set di convalida.
   Il modo migliore ma più impegnativo per consentire a un paradigma di apprendimento di affrontare grandi set di dati sarebbe quello di sviluppare nuovi algoritmi con complessità computazionale più bassa. In alcuni casi, è probabilmente impossibile derivare algoritmi esatti con una complessità inferiore. Gli studenti degli alberi decisionali che trattano di attributi numerici rientrano in questa categoria. La loro complessità temporale asintotica è dominata dal processo di ordinamento per i valori di attributo numerico, una procedura che deve essere eseguita almeno una volta per ogni dato set di dati. A volte possono essere derivati ​​algoritmi stocastici che approssimano la vera soluzione ma richiedono una quantità molto minore di tempo.

   La conoscenza della priorità può consentire di ridurre notevolmente la quantità di dati che deve essere elaborata da un algoritmo di apprendimento. A seconda di quale attributo è la classe, la maggior parte degli attributi in un set di dati enorme potrebbe risultare irrilevante quando viene presa in considerazione la conoscenza della priorità. Come al solito, paga per accuratamente ingegnerizzare i dati che vengono trasmessi allo schema di apprendimento e fare il massimo uso di qualsiasi informazione preliminare sul problema di apprendimento a portata di mano. Se non è disponibile una conoscenza di base insufficiente, gli algoritmi di filtraggio degli attributi descritti nella Sezione 7.1 possono spesso ridurre drasticamente la quantità di dati, forse a scapito di una minore perdita di prestazioni predittive. Alcuni di questi - ad esempio, la selezione degli attributi utilizzando alberi decisionali o lo schema di apprendimento 1R - sono lineari nel numero di attributi.

   Solo per dare una sensazione per la quantità di dati che possono essere gestite da semplici implementazioni di algoritmi di apprendimento macchina su ordinari microcomputer, abbiamo eseguito l'albero decisionale J4.8 su un set di dati con 600.000 istanze, 54 attributi (10 numeri e 44 binari ) E una classe con sette valori. Abbiamo utilizzato un processore Pentium 4 con un clock da 2,8 GHz e una macchina virtuale Java con un "compilatore appena in tempo". Ci sono voluti 40 minuti per caricare il file di dati, costruire l'albero utilizzando potatura a errori ridotti e classificare tutti Le istanze di formazione. L'albero aveva 20.000 nodi. Si noti che questa implementazione è scritta in Java e l'esecuzione di un programma Java è spesso più volte più veloce di un programma corrispondente scritto in C perché il codice byte di Java deve essere tradotto in codice macchina prima che possa essere eseguito. (Nella nostra esperienza la differenza è di solito un fattore da tre a cinque se la macchina virtuale utilizza un compilatore justin-time.)
   Oggi esistono set di dati che meritano veramente l'aggettivo massivo. I set di dati scientifici provenienti da astrofisica, fisica nucleare, scienza della terra e biologia molecolare sono misurate in centinaia di gigabyte - o addirittura di terabyte. Quindi sono i set di dati che contengono record di transazioni finanziarie. L'applicazione di programmi standard per l'apprendimento automatico a tali set di dati nella loro interezza è una proposta molto impegnativa.
   Incorporating domain knowledge

  Durante tutto questo libro abbiamo sottolineato l'importanza di conoscere i tuoi dati durante l'attività di estrazione dei dati pratici. La conoscenza del dominio è assolutamente indispensabile per il successo. I dati sui dati vengono spesso chiamati metadati e una delle frontiere dell'apprendimento automatico è lo sviluppo di schemi che permettano ai metodi di apprendimento di tenere in considerazione metadati in modo utile.

   Non si deve guardare molto per esempi di come metadati possono essere applicati. Nel Capitolo 2 abbiamo diviso gli attributi in nominal e numerici. Ma abbiamo anche notato che molte distinzioni più fini sono possibili. Se un attributo è numerico, l'ordine è implicito, ma a volte c'è un punto zero e talvolta non (per intervalli di tempo, ma per date non c'è). Anche l'ordine può essere non standard: i gradi angolari hanno un ordine diverso da quello degli interi, perché 360 ° è lo stesso di 0 ° e 180 ° è uguale a -180 ° o addirittura a 900 °. Gli schemi di discretizzazione assumono ordini ordinari ordinari, come gli schemi di apprendimento che soddisfano gli attributi numerici, ma sarebbe una questione di routine per estenderli alle ordinazioni circolari. Possono essere ordinati anche dati categorici. Immagina quanto sarebbe più difficile la nostra vita se non ci fosse un ordinamento convenzionale per le lettere dell'alfabeto. (La ricerca di un elenco nella rubrica telefonica di Hong Kong presenta un problema interessante e non triviale!) E i ritmi della vita quotidiana si riflettono nelle ordinazioni circolari: giorni della settimana, mesi dell'anno. Per complicare ulteriormente le questioni ci sono molti altri tipi di ordinamento, come le ordinazioni parziali sui sottoinsiemi: il sottoinsieme A può includere il sottoinsieme B, il sottoinsieme B può includere il sottoinsieme A o nessuno dei due può includere l'altro. L'estensione dei programmi di apprendimento ordinario per tenere conto di questo tipo di informazioni in modo soddisfacente e generale è un problema di ricerca aperta.

    Metadati spesso coinvolge rapporti tra attributi. Si distinguono tre tipi di relazioni: semantiche, causali e funzionali. Una relazione semantica tra due attributi indica che se il primo è incluso in una regola, anche il secondo dovrebbe essere. In questo caso, è noto a priori che gli attributi hanno un senso solo insieme. Ad esempio, nei dati agricoli che abbiamo analizzato, un attributo chiamato produzione di latte misura quanta latte produce una vacca individuale e lo scopo della nostra indagine ha significato che questo attributo aveva una relazione semantica con tre altri attributi, identificatore della mucca, Identificatore e agricoltore. In altre parole, un valore di produzione di latte può essere compreso solo nel contesto della mucca che ha prodotto il latte e la mucca è ulteriormente legata ad una mandria specifica di un determinato contadino. Le relazioni semantiche, naturalmente, dipendono dal problema: non dipendono solo dal set di dati, ma anche da ciò che stai cercando di fare con esso.
   Le relazioni causali si verificano quando un attributo provoca un'altra. In un sistema che cerca di prevedere un attributo causato da un altro, sappiamo che l'altro attributo deve essere incluso per rendere significativa la predizione. Ad esempio, nei dati agricoli menzionati in precedenza, c'è una catena di identificazione di coltivatori, branchi e mucche, attraverso attributi misurati come la produzione di latte, fino all'attributo che registra se una determinata mucca è stata mantenuta o venduta dall'agricoltore. Le regole apprese dovrebbero riconoscere questa catena di dipendenza.

   Le dipendenze funzionali si verificano in molti database e le persone che creano dei database cercano di identificarli allo scopo di normalizzare le relazioni nel database. Quando apprendere dai dati, il significato di una dipendenza funzionale di un attributo su un altro è che se quest'ultimo viene utilizzato in una regola non c'è bisogno di considerare l'ex. I programmi di apprendimento spesso riscoprono le dipendenze funzionali già note. Non solo questo genera norme senza senso, o più accuratamente tautologiche, ma anche altri, modelli più interessanti possono essere oscurati dalle relazioni funzionali. Tuttavia, è stato molto lavoro nella progettazione automatica dei database sul problema di inferire dipendenze funzionali dalle query di esempio e i metodi sviluppati dovrebbero risultare utili per eliminare le regole tautologiche generate dai sistemi di apprendimento.
   Prendendo in considerazione questi tipi di metadati o conoscenze precedenti del dominio quando si effettua l'induzione utilizzando uno qualsiasi degli algoritmi che abbiamo incontrato non sembra presentare alcuna sfida tecnica o profonda. L'unico vero problema - ed è un grande - è come esprimere i metadati in modo generale e facilmente comprensibile in modo che possa essere generato da una persona e utilizzato dall'algoritmo.

    Sembra interessante appendere la conoscenza dei metadati nella stessa rappresentazione che genera lo schema di apprendimento macchina. Ci concentriamo su regole, che sono la norma per gran parte di questo lavoro. Le regole che specificano i metadati corrispondono alla conoscenza precedente del dominio. Considerati esempi di addestramento, regole aggiuntive possono essere ricavate da uno dei regimi di induzione di regole che abbiamo già incontrato. In questo modo, il sistema potrebbe essere in grado di combinare "esperienza" (da esempi) con "teoria" (dalla conoscenza del dominio). Sarebbe in grado di confermare e modificare la sua conoscenza programmata basata su prove empiriche. Mettendo loop, l'utente racconta al sistema ciò che lui sa, gli dà alcuni esempi e fa il resto per se stesso!
    Per utilizzare le conoscenze precedenti espresse come regole in modo sufficientemente flessibile, è necessario che il sistema sia in grado di eseguire una deduzione logica. Altrimenti, la conoscenza deve essere espressa proprio nel modo giusto per l'algoritmo di apprendimento per sfruttarlo, probabilmente troppo esigente per l'uso pratico. Consideriamo i metadati causali: se A causa B e B provoca C, allora vorremmo che il sistema deduce che A causa C anziché dover dire esplicitamente questo fatto. Anche se in questo semplice esempio, esplicitamente affermando che il nuovo fatto presenta un piccolo problema, in pratica, con metadati estesi, sarà irrealistico aspettarsi che gli utenti del sistema esprimano tutte le conseguenze logiche della loro conoscenza precedente.

 

Una combinazione di deduzione dalla conoscenza del dominio prefissato e dall'induzione da esempi di formazione sembra un modo flessibile di accedere ai metadati. Ad un estremo, quando gli esempi sono scarsi (o inesistenti), la deduzione è il primo (o unico) mezzo per generare nuove regole. Dall'altro, quando gli esempi sono abbondanti ma i metadati sono scarsi (o inesistenti), le tecniche standard di apprendimento delle macchine descritte in questo libro sono sufficienti. Situazioni pratiche spaziano il territorio tra.
   Questa è una visione imponente ei metodi di programmazione logica induttiva, menzionati nella sezione 3.6, offrono un modo generale di specificare la conoscenza del dominio in modo esplicito attraverso istruzioni in una lingua logica formale. Tuttavia, le soluzioni di programmazione logica correnti subiscono gravi carenze in ambienti reali. Tendono a essere fragili e mancano di robustezza, e possono essere così computazionali per essere completamente impossibili su set di dati di qualsiasi dimensione pratica. Forse questo deriva dal fatto che utilizzano la logica del primo ordine, cioè consentono di introdurre le variabili nelle regole. I sistemi di apprendimento della macchina che abbiamo visto, i cui input e output sono rappresentati in termini di attributi e valori costanti, eseguono le loro lavorazioni nella logica proposizionale senza variabili, riducendo notevolmente lo spazio di ricerca e evitando ogni sorta di difficili problemi di circolarità e terminazione. Alcuni aspirano a realizzare la visione senza la fragilità di accompagnamento e la infallibilità computazionale delle soluzioni complete di programmazione logica adottando sistemi di ragionamento semplificati. Altri inseriscono la loro fede nel meccanismo generale delle reti bayesiane, introdotte nella sezione 6.7, in cui i vincoli causali possono essere espressi nella struttura di rete iniziale e le variabili nascoste possono essere postulate e valutate automaticamente. Sarà interessante vedere se sistemi che consentano la definizione flessibile di diversi tipi di conoscenze di dominio diventeranno ampiamente distribuiti.
    Text and Web mining

  La data mining riguarda la ricerca di modelli nei dati. Allo stesso modo, l'estrazione del testo riguarda la ricerca di modelli nel testo: è il processo di analisi del testo per estrarre informazioni utili a scopi particolari. Rispetto al tipo di dati che abbiamo parlato in questo libro, il testo è non strutturato, amorfo e difficile da affrontare. Tuttavia, nella moderna cultura occidentale, il testo è il veicolo più comune per lo scambio formale delle informazioni. La motivazione per cercare di estrarre le informazioni da esso è convincente, anche se il successo è solo parziale.

   La somiglianza superficiale tra testo e data mining nasconde reali differenze. Nel capitolo 1 abbiamo caratterizzato l'attività di data mining come estrazione di informazioni implicite, precedentemente sconosciute e potenzialmente utili da dati. Tuttavia, con l'estrazione del testo, le informazioni da estrarre sono chiaramente ed esplicitamente indicate nel testo. Non è nascosto affatto la maggior parte degli autori vanno a grandi dolori per assicurarsi che si esprimano in modo chiaro e inequivocabile. Dal punto di vista umano, l'unico senso in cui è "sconosciuto" è che le restrizioni temporali lo rendono impossibile per le persone a leggere il testo stesso. Il problema, ovviamente, è che le informazioni non sono apposte in un modo che sia responsabile dell'elaborazione automatica. L'estrazione del testo tenta di portarla in una forma adatta al consumo da parte di computer o da persone che non hanno tempo per leggere il testo completo

   Un requisito comune per entrambi i dati e l'estrazione del testo è che le informazioni estratte dovrebbero essere potenzialmente utili. In un certo senso, ciò significa azione utile capace di creare una base per le azioni da intraprendere automaticamente. Nel caso del data mining, questa nozione può essere espressa in un modo relativamente indipendente dal dominio: i modelli attivati ​​sono quelli che consentono di fare previsioni non triviali su nuovi dati della stessa fonte. La prestazione può essere misurata conteggiando i successi e gli errori, le tecniche statistiche possono essere applicate per confrontare metodi di estrazione dati diversi sullo stesso problema e così via. Tuttavia, in molte situazioni di estrazione del testo, è difficile caratterizzare ciò che "azione" significa in un modo indipendente dal particolare dominio a portata di mano. Ciò rende difficile trovare misure eque e obiettive di successo.
   Come abbiamo sottolineato in tutto questo libro, "potenzialmente utile" viene spesso dato un'altra interpretazione nella pratica di data mining: la chiave per il successo è che le informazioni estratte devono essere comprensibili in quanto aiutano a spiegare i dati. Ciò è necessario ogni volta che il risultato sia destinato al consumo umano piuttosto che (o anche) per l'azione automatica. Questo criterio è meno applicabile all'estrazione del testo perché, a differenza dell'estrazione dei dati, l'input è comprensibile. L'estrazione del testo con l'output comprensibile equivale a riassumere le caratteristiche salienti da un grande corpo di testo, che è un sottocampo di per sé: sintesi di testo.
    Abbiamo già riscontrato un importante problema di estrazione del testo: la classificazione dei documenti, in cui ogni istanza rappresenta un documento e la classe dell'istanza è l'argomento del documento. I documenti sono caratterizzati dalle parole che appaiono in essi. La presenza o l'assenza di ciascuna parola può essere considerata come un attributo booleano oppure i documenti possono essere trattati come sacchetti di parole, piuttosto che insiemi, tenendo conto delle frequenze di parola. Abbiamo incontrato questa distinzione nel paragrafo 4.2, dove abbiamo imparato a estendere Naïve Bayes alla rappresentazione "bag-of-words", dando la versione multinomiale dell'algoritmo.

  Naturalmente, c'è un immenso numero di parole diverse, e la maggior parte di loro non è molto utile per la classificazione dei documenti. Questo presenta un classico problema di selezione delle funzioni. Alcune parole, ad esempio, le parole di funzione, spesso chiamate stopwords, possono essere eliminate a priori, ma anche se queste si verificano molto spesso, non sono molte di esse. Altre parole si verificano così raramente che sono improbabili per essere utili per la classificazione. Paradossalmente, sono frequenti le parole rare: quasi la metà delle parole in un tipico documento o corpus di documenti si verificano una sola volta. Tuttavia, tale numero enorme di parole rimane dopo che queste classi di parole vengono rimosse, che la selezione di ulteriori funzionalità può essere necessaria utilizzando i metodi descritti nella Sezione 7.1. Un altro problema è che il modello "bag- (o set-) di parole" trascura l'ordine di parola e gli effetti contestuali. C'è un forte caso per individuare frasi comuni e trattarle come singole unità.
  La classificazione dei documenti è l'apprendimento supervisionato: le categorie sono note in anticipo e sono fornite in anticipo per ogni documento di formazione. La versione senza sorveglianza del problema si chiama cluster di documenti. Qui non esiste una classe predefinita, ma vengono ricercati gruppi di documenti cognati. Il cluster di documenti può aiutare il recupero di informazioni creando collegamenti tra documenti simili, che a sua volta consente di recuperare documenti correlati una volta che uno dei documenti è stato considerato rilevante per una query   

  Ci sono molte applicazioni di classificazione dei documenti. Un compito di categorizzazione relativamente semplice, l'identificazione delle lingue, fornisce un importante pezzo di metadati per i documenti nelle collezioni internazionali. Una semplice rappresentazione che funziona bene per l'identificazione della lingua è caratterizzare ogni documento da un profilo che consiste nei n-grammi o sequenze di n lettere consecutive che appaiono. I più frequenti 300 grammi n-grammi sono altamente correlati con il linguaggio. Un'applicazione più impegnativa è l'assegnazione di autori in cui l'autore di un documento è incerto e deve essere indovinato dal testo. Qui, le parole d'ordine, non le parole di contenuto, sono il gifting, perché la loro distribuzione è dipendente dall'autore, ma indipendente dall'argomento. Un terzo problema è l'assegnazione di frasi chiave a documenti provenienti da un vocabolario controllato di possibili frasi, dato un gran numero di documenti formativi che sono contrassegnati da questo vocabolario.

   Un'altra classe generale di problemi di estrazione dei testi è l'estrazione dei metadati. Metadati sono stati menzionati in precedenza come dati sui dati: nel campo del testo il termine si riferisce generalmente a caratteristiche salienti di un lavoro, come il suo autore, titolo, classificazione di soggetti, intestazioni di soggetto e parole chiave. I metadati sono una sorta di riepilogo di documenti altamente strutturati (e quindi attivi). L'idea di metadati è spesso estesa per comprendere parole o frasi che rappresentano oggetti o "entità" nel mondo, portando alla nozione di estrazione di entità. I documenti ordinari sono pieni di tali termini: numeri di telefono, numeri di fax, indirizzi di strada, indirizzi e-mail, firme e-mail, abstract, tabelle di contenuto, elenchi di riferimenti, tabelle, figure, didascalie, annunci di riunione, indirizzi web e altro ancora. Inoltre, ci sono innumerevoli entità specifiche di dominio, come numeri di libri internazionali standard (ISBN), simboli di scorta, strutture chimiche e equazioni matematiche. Questi termini agiscono come singoli elementi vocabolario e molte attività di elaborazione dei documenti possono essere migliorate significativamente se identificate come tali. Possono aiutare la ricerca, l'interconnessione e il cross-referencing tra documenti.

   Come identificare le entità testuali? L'apprendimento di rotazione, vale a dire la ricerca di dizionario, è un'idea, in particolare quando è associato a risorse esistenti: elenchi di nomi e organizzazioni personali, informazioni sulle località dei giornalisti o dizionari di abbreviazione e acronimo. Un'altra è usare modelli di capitalizzazione e punteggiatura per nomi e acronimi; Titoli (Ms.), suffissi (Jr.) e prefissi baronali (von); O statistiche linguistiche inusuali per i nomi stranieri. Sono sufficienti espressioni regolari per i costrutti artificiali come i locatori di risorse uniformi (URL); Grammari espliciti possono essere scritti per riconoscere date e somme di denaro. Anche il compito più semplice offre opportunità per imparare ad affrontare l'enorme variazione che i documenti realmente presenti. Come un esempio, cosa potrebbe essere più semplice di cercare un nome in una tabella? Ma il nome del leader libico Muammar Gheddafi è rappresentato in 47 modi diversi su documenti ricevuti dalla Biblioteca del Congresso!

   Molti documenti brevi descrivono un particolare tipo di oggetto o evento, che unisce entità in un composito di livello superiore che rappresenta l'intero contenuto del documento. Il compito di identificare la struttura composita, che può spesso essere rappresentata come un modello con slot che sono riempiti da singoli pezzi di informazioni strutturate, si chiama estrazione di informazioni. Una volta che le entità sono state trovate, il testo viene analizzato per determinare le relazioni tra di loro. I problemi tipici di estrazione richiedono la ricerca della struttura predicato di un piccolo insieme di proposizioni predeterminate. Questi sono di solito abbastanza semplici da catturare con tecniche di analisi poco profonde come piccole grammatiche finite di stato, anche se le questioni possono essere complicate da riferimenti ambigui dei pronomi e frasi preposizionali allegate e altri modificatori. L'apprendimento automatico è stato applicato all'estrazione di informazioni cercando regole che estraggono i riempitivi per le slot nel modello. Queste regole possono essere raggruppate in forma di pattern-action, i modelli che esprimono vincoli sul slot-filler e sulle parole nel suo contesto locale. Questi vincoli possono coinvolgere le stesse parole, i loro segni parziali e le loro classi semantiche.

  Prendendo un ulteriore passo avanti l'estrazione delle informazioni, le informazioni estratte possono essere utilizzate in un passaggio successivo per apprendere le regole, non le regole su come estrarre informazioni, ma le regole che caratterizzano il contenuto del testo stesso. Queste regole potrebbero prevedere i valori di alcuni slot-filler dal resto del testo. In determinate situazioni fortemente vincolate, come ad esempio le posizioni di lavoro su Internet per lavori connessi al calcolo, l'estrazione di informazioni basata su alcuni esempi di formazione costruiti manualmente può competere con un intero database costruito manualmente in termini di qualità delle regole dedotte.
  Il World Wide Web è un enorme repository di testo. Quasi tutto è diverso dal normale testo "puro" perché contiene un taglio strutturale esplicito. Alcuni marcatori sono interni e indicano la struttura o il formato del documento; L'altro marchio è esterno e definisce i collegamenti ipertestuali espliciti tra i documenti. Queste fonti di informazioni forniscono una ulteriore leva per estrarre i documenti Web. L'estrazione del Web è come l'estrazione del testo, ma sfrutta le informazioni aggiuntive e spesso migliora i risultati capitalizzando l'esistenza di directory di argomenti e altre informazioni sul Web.

  Le risorse di Internet che contengono directory relazionali di dati telefoniche o cataloghi di prodotti - utilizzano i comandi di formattazione HTML (HTML) per indicare chiaramente le informazioni che contengono agli utenti Web. Tuttavia, è molto difficile estrarre automaticamente dati da tali risorse. A tal fine, i sistemi software esistenti utilizzano moduli di parsing semplici chiamati wrapper per analizzare la struttura della pagina e estrarre le informazioni necessarie. Se i wrapper sono codificati manualmente, spesso, questo è un tipo banale di estrazione del testo perché si basa sulle pagine con una struttura fissa e predeterminata da cui le informazioni possono essere estratte algoritmicamente. Ma le pagine raramente obbediscono alle regole. Le loro strutture variano; I siti web si evolvono. Gli errori che sono insignificanti per i lettori umani lanciano completamente inutili le procedure di estrazione automatica. Quando si verifica un cambiamento, la regolazione manualmente di un involucro può essere un incubo che comporta l'acquisizione della testa intorno al codice esistente e la patchizzazione in un modo che non provoca rottura altrove.

  Immettere automaticamente i wrapper di apprendimento ad avvolgimento da esempi. L'input è un set di formazione di pagine insieme a tuple che rappresentano le informazioni derivate da ciascuna pagina. L'output è un insieme di regole che estrae le tuple analizzando la pagina. Ad esempio, potrebbe cercare determinati elementi di delimitatore HTML, i limiti di paragrafo (<p>), le voci di elenco (<li>) o grassetto (<b>) che il progettista di pagine web ha utilizzato per disattivare elementi chiave di informazioni, E imparare la sequenza in cui vengono presentate le entità. Ciò potrebbe essere compiuto ripetendo su tutte le scelte di delimitatori, fermandosi quando si incontra un involucro coerente. Poi il riconoscimento dipenderà solo da una serie minima di segnali, fornendo una certa difesa contro i testi estranei ei marcatori nell'ingresso. In alternativa, si potrebbe seguire il consiglio di Epicurus alla fine della Sezione 5.9 e cercare un robusto involucro che utilizza più segnali per proteggere contro la variazione accidentale. Il grande vantaggio dell'induzione di avvolgimento automatico è che quando gli errori sono causati da varianti stilistiche è semplice aggiungerli ai dati di formazione e reindirizzare un nuovo involucro che li tiene conto. L'induzione di avvolgimento riduce i problemi di riconoscimento quando si verificano piccoli cambiamenti e rende molto più facile produrre nuovi set di regole di estrazione quando le strutture cambiano radicalmente.

   Uno sviluppo chiamato il Web semantico mira a consentire alle persone di pubblicare informazioni in modo tale che la struttura e la semantica siano esplicite in modo che possano essere ripristinati anziché semplicemente letti. Ciò renderebbe superfluo l'induzione dell'involucro. Ma se e quando viene implementato il Web semantico, il requisito del markup manuale, per non parlare dei grandi volumi di pagine precedenti, aumenta probabilmente la domanda di introduzione automatica della struttura dell'informazione.
   L'estrazione del testo, inclusa l'estrazione del Web, è una tecnologia che è ancora in crescita, a causa della sua novità e delle difficoltà intrinseche, in uno stato fluido, forse allo stato di apprendimento automatico alla metà degli anni '80. Non esiste un reale consenso su ciò che riguarda: interamente interpretato, tutte le elaborazioni linguistiche naturali rientrano nell'ambito dell'estrazione del testo. Di solito è difficile fornire valutazioni generali e significative in quanto l'attività mineraria è altamente sensibile al particolare testo in esame. Le tecniche di smistamento automatico dei testi hanno molto da fare prima di competere con la capacità delle persone, anche senza conoscenze specifiche del dominio, di raccogliere informazioni dalle grandi raccolte di documenti. Ma andranno molto, perché la domanda è immensa.
       Adversarial situations

  Una prima applicazione di apprendimento automatico è il filtraggio e-mail spazzatura. Mentre scriviamo queste parole (alla fine del 2004), il flagello dell'e-mail indesiderato è un problema che brucia, ma al tempo che li leggete la bestia sarà stata vinta o almeno addomesticata. A prima vista, il filtraggio e-mail di rottura di spazzatura sembra presentare un problema standard della classificazione dei documenti: divide i documenti in "ham" e "spam" sulla base del testo che contengono, guidati da dati formativi, di cui sono copiose quantità. Ma non è un problema standard perché coinvolge un aspetto contraddittorio. I documenti che vengono classificati non vengono scelti in modo casuale da un insieme inimmaginabile di tutti i documenti possibili; Contengono e-mail che vengono progettati con cura per evadere il processo di filtraggio, progettato appositamente per battere il sistema

  I primi filtri anti-spam hanno semplicemente scartato messaggi contenenti parole "spammy" che connotano cose come il sesso, il lucre e il quackery. Naturalmente, molte corrispondenze legittime riguardano il genere, il denaro e la medicina: bisogna affrontare un equilibrio. Così i progettisti di filtri reclutarono schemi Bayesian di classificazione dei testi che hanno imparato a trovare un equilibrio appropriato durante il processo di formazione. Gli spammer si adattarono rapidamente alle tecniche che nascondevano le parole spammie scritte in modo scorretto; Li ha travolti con un testo legittimo, forse stampato in bianco su uno sfondo bianco in modo che solo il filtro lo abbia visto; O semplicemente mettere il testo di spam altrove, in un'immagine o un URL che la maggior parte dei lettori di posta elettronica scarica automaticamente.
   Il problema è complicato dal fatto che è difficile confrontare obiettivamente gli algoritmi di rilevazione di spam; Anche se i dati formativi sono abbondanti, le questioni relative alla privacy impediscono la pubblicazione di grandi corporazioni pubbliche di email rappresentative. E ci sono forti effetti temporali. Spam cambia rapidamente il carattere, invalidando test statistici sensibili come la convalida incrociata. Infine, i cattivi possono anche usare l'apprendimento macchina. Ad esempio, se riuscivano a trovare esempi di ciò che i filtri bloccano e ciò che lascia attraverso, potrebbero utilizzare questo come dati di formazione per imparare a evadere.

   Ci sono, purtroppo, molti altri esempi di "situazioni di apprendimento contraddittorie" nel nostro mondo di oggi. Chiaramente legato alla posta indesiderata è lo spam di motori di ricerca: i siti che tentano di ingannare i motori di ricerca di Internet inserendoli in modo prominente nelle liste dei risultati di ricerca. Le pagine altamente classificate offrono vantaggi economici diretti ai propri proprietari perché presentano opportunità di pubblicità, fornendo una forte motivazione ai cercatori di profitti. Poi ci sono le guerre di virus del computer, in cui i progettisti di virus e software di protezione antivirus reagiscono alle innovazioni di un altro. Qui la motivazione tende ad essere una rottura generale e una negazione del servizio, piuttosto che guadagno monetario.
  La sicurezza della rete informatica è una battaglia in continua espansione. Le protezioni induriscono le reti, i sistemi operativi e le applicazioni e gli aggressori trovano vulnerabilità in tutte e tre le aree. I sistemi di rilevamento delle intrusioni sniffano modelli inusuali di attività che potrebbero essere causati da un'attività di ricognizione dell'hacker.
   Gli aggressori lo rendono conto e cercano di oscurare i loro sentieri, forse lavorando indirettamente o diffondendo le loro attività per un lungo periodo - o, viceversa, colpendo molto velocemente. Data mining viene applicato a questo problema nel tentativo di scoprire connessioni semantiche tra le tracce di attaccanti nei dati della rete computer che i sistemi di rilevamento delle intrusioni mancano. Questo è un problema di grande scala: i registri di controllo utilizzati per monitorare la sicurezza della rete di computer possono ammontare a gigabyte al giorno anche in organizzazioni di medie dimensioni.

   Molti sistemi automatizzati di rilevazione delle minacce si basano sulla corrispondenza dei dati correnti con i tipi di attacco noti. L'Amministrazione federale dell'aviazione federale ha sviluppato il sistema di pre-screening del passeggero assistito da computer (CAPPS), che esamina i passeggeri della compagnia aerea sulla base dei loro record di volo e bandiera gli individui per ulteriori screening dei bagagli registrati. Sebbene i dettagli esatti siano inediti, CAPPS è per esempio pensato di assegnare punteggi più elevati alla minaccia ai pagamenti in denaro. Tuttavia, questo approccio può rilevare solo minacce note o anticipate. I ricercatori stanno utilizzando approcci senza supervisione, come l'anomalia e l'individuazione più esterna nel tentativo di rilevare attività sospette. Oltre a segnalare le potenziali minacce, i sistemi di rilevamento anomalie possono essere applicati alla rilevazione di attività illegali come la frode finanziaria e il riciclaggio di denaro.
  La data mining è oggi utilizzata per analizzare enormi volumi di dati in nome della difesa patria. Le informazioni eterogenee come le transazioni finanziarie, le registrazioni sanitarie e il traffico di rete vengono estratte per creare profili, costruire modelli di social network e individuare le comunicazioni terroristiche. Questa attività solleva gravi preoccupazioni sulla privacy e ha portato allo sviluppo di tecniche di estrazione dei dati che tutelano la privacy. Questi algoritmi cercano di discernere i modelli nei dati senza accedere direttamente ai dati originali, tipicamente distorcendo i valori casuali. Per preservare la privacy, essi devono garantire che il processo di estrazione non riceve informazioni sufficienti per ricostruire i dati originali. Questo è più facile da dire che da fare.

  Su una nota più leggera, non tutti i dati contraddittori di data mining sono mirati a combattere attività malvagie. I sistemi multiagenti in domini complessi e rumorosi in tempo reale implicano agenti autonomi che devono collaborare in una squadra e competere contro gli antagonisti. Se hai problemi a visualizzarlo, pensa a calcio. Il Robo-Soccer è un dominio ricco e popolare per esplorare come l'apprendimento delle macchine può essere applicato a tali problemi difficili. I giocatori non devono solo affinare le competenze a basso livello ma devono anche imparare a lavorare insieme e adattarsi ai modelli di comportamento di diversi avversari.

  Infine, l'apprendimento macchina è stato usato per risolvere un mistero letterario storico smascherando un autore prolifico che aveva tentato di nascondere la sua identità. Come riferisce Koppel e Schler (2004), Ben Ish Chai è stato il principale studioso rabbinico a Baghdad alla fine dell'Ottocento. Tra la sua vasta eredità letteraria sono due raccolte distinte di circa 500 lettere ebraico-aramaiche scritte in risposta alle domande legali. È conosciuto per aver scritto una sola collezione. Anche se sostiene di aver trovato l'altro in un archivio, gli storici sospettano che egli stesso abbia scritto, ma ha tentato di mascherare la sua autrice cambiando deliberatamente il suo stile. Il problema che questo caso presenta all'applicazione della macchina è che non esiste un corpus di lavoro da attribuire all'autore del mistero. C'erano alcuni candidati noti, ma le lettere potrebbero essere altrettanto ben scritte da chiunque altro. È stata sviluppata una nuova tecnica appositamente chiamata smascheratura che crea un modello per distinguere il lavoro dell'autore noto A dall'opera sconosciuta dell'autore X, rimuove iterativamente quelle funzionalità più utili per distinguere i due e esamina la velocità con la quale l'accuratezza della convalida incrociata Come vengono rimosse più funzionalità.

  L'ipotesi è che se l'opera X è scritta dall'autore dell'opera A che cerca di nascondere la sua identità, qualunque differenza tra il lavoro X e il lavoro A si rifletta solo in un numero relativamente piccolo di caratteristiche rispetto alle differenze tra il lavoro X E le opere di un altro autore, diciamo l'autore del lavoro B. In altre parole, quando il lavoro X viene confrontato con le opere A e B, la curva di precisione come funzionalità viene rimossa diminuirà molto più velocemente per il lavoro A che non per il lavoro B Koppel e Schler hanno concluso che Ben Ish Chai ha effettivamente scritto le lettere misteriose e la loro tecnica è un esempio sorprendente dell'uso originale e creativo dell'approccio macchina in una situazione "contraddittoria".

     Ubiquitous data mining

  Abbiamo iniziato questo libro sottolineando che siamo sopraffatti con i dati. Da un punto di vista questo non influenza la vita di persone ordinarie più che sul World Wide Web. Attualmente il Web contiene più di 5 miliardi di documenti, per un totale di circa 20 TB e continua a crescere in modo esponenziale, raddoppiando ogni 6 mesi o giù di lì. La maggior parte dei consumatori Usa usa il Web. Nessuno di loro può tenere il passo con l'esplosione delle informazioni. Mentre le attività di data mining sono state originate nel mondo aziendale, in quanto i database sono, l'estrazione di testo spinge la tecnologia di apprendimento delle macchine dalle aziende e dalla casa. Ogni volta che siamo sopraffatti dai dati sul Web, l'estrazione del testo promette strumenti per attenuarla. Le applicazioni sono legioni. Trovare amici e contattarli, mantenere i portafogli finanziari, acquistare acquisti in un mondo elettronico, utilizzando rivelatori di dati di qualsiasi tipo, tutti questi potrebbero essere realizzati automaticamente senza una programmazione esplicita. Le tecniche di estrazione del testo sono già state utilizzate per prevedere quale link verrà scelto successivamente, per organizzare i documenti e per ordinare la tua posta. In un mondo in cui le informazioni sono travolgenti, disorganizzate e anarchiche, l'estrazione del testo può essere la soluzione che abbiamo tanto disperatamente bisogno.

  Molti credono che il Web non è altro che il tracciato di un cambiamento paradigmatico ancora più grande: l'informazione onnipresente. I piccoli dispositivi portatili sono ovunque: telefoni cellulari, assistenti digitali personali, lettori stereo e video personalizzati, fotocamere digitali, accesso Web mobile. Già alcuni dispositivi integrano tutte queste funzioni. Conoscono la nostra posizione nel tempo fisico e nello spazio fisico, ci aiutano a comunicare nello spazio sociale, organizzano il nostro spazio personale di pianificazione, ricordano il nostro passato e ci avvolgono nello spazio informativo globale. È facile trovare decine di processori in una casa di classe media negli Stati Uniti oggi. Non comunicano tra loro o con l'infrastruttura globale di informazione. Ma lo faranno, e quando verrà fatto il potenziale per l'estrazione dei dati "salirà".
   Prendi la musica di consumo. La musica popolare porta l'avanguardia del progresso tecnologico. Walkman originale di Sony ha aperto la strada all'elettronica portatile di oggi. L'iPod di Apple è stato uno dei più grandi archivi portatili. La tecnologia di rete di Napster ha stimolato lo sviluppo di protocolli peer-to-peer. I sistemi raccomandati come Firefly hanno portato il calcolo alle reti sociali. 'In un prossimo futuro' i servizi musicali con contenuti consapevoli migreranno su dispositivi portatili. Le applicazioni per l'estrazione dei dati nelle comunità di utenti di servizi di musica in rete saranno legioni: scoprire le tendenze musicali, seguire le preferenze ei gusti e analizzare i comportamenti d'ascolto.

  L'informatica onnipresente "intreccia lo spazio digitale da vicino" in attività del mondo reale. A molti, l'estrapolazione frustante delle proprie esperienze computerizzate, tecnologia arcaica, "l'inadeguatezza personale percepita" e "il guasto alla macchina", questo suona come un incubo. Ma i sostenitori sottolineano che non può essere così, perché, se è vero, non funzionerà. I visionari di oggi prevedono un mondo di calcolo "calma" in cui le macchine nascoste silenziosamente cospirano dietro le quinte per rendere la vita più ricca e più facile. Troveranno oltre i grossi problemi di finanza aziendale e compiti a scuola per i piccoli fastidi, come ad esempio dove sono le chiavi dell'auto, posso trovare un posto auto e quella maglia che ho visto la settimana scorsa a Macy ancora sul rack? Gli orologi troveranno il tempo corretto dopo un interruzione di corrente, il microonde riceverà nuove ricette da Internet e i giocattoli per bambini si aggiorneranno con nuovi giochi e nuovi vocabolari. Le etichette dei vestiti seguiranno il lavaggio, le tazze di caffè avviseranno il personale addetto alla pulizia allo stampo, gli interruttori di luce risparmiano energia se nessuno è nella stanza e le matite digitalizzeranno tutto quello che disegniamo. Dove l'estrazione dei dati sarà in questo nuovo mondo? Ovunque!

  È difficile indicare esempi di un futuro che non esiste ancora. Ma i progressi nella tecnologia dell'interfaccia utente sono suggestivi. Molti compiti ripetitivi "nelle interfacce deo computer diconfigurazione" non possono essere automatizzate con gli strumenti standard di applicazione che costringono gli utenti di eseguire ripetutamente le stesse azioni di interfaccia. Questo caratterizza le frustrazioni alluse in precedenza: chi è responsabile o me? I programmatori esperti potrebbero scrivere uno script per eseguire tali operazioni per loro conto, ma poiché i sistemi operativi accumulano strato su strato di complessità, la potenza dei programmatori a comandare la macchina è erosa e svanisce totalmente quando funzionalità complesse sono incorporate negli apparecchi piuttosto che nei computers periferici ".

  La ricerca nella programmazione mediante la dimostrazione consente agli utenti di computer comuni di automatizzare attività predittive senza richiedere alcuna conoscenza di programmazione affatto. L'utente deve sapere solo come eseguire l'attività nel modo consueto per poterlo comunicare al computer. Un sistema denominato Familiar consente agli utenti di automatizzare attività iterative che implicano applicazioni esistenti nei computer Macintosh. Funziona attraverso le applicazioni e può lavorare con quelli completamente nuovi mai incontrati. Lo fa utilizzando il linguaggio di script di Apple per raccogliere informazioni da ogni applicazione e sfruttare queste informazioni per fare previsioni. L'agente tollera il rumore. Genera spiegazioni per informare l'utente del computer sulle sue previsioni, e include risposte. È adattabile: impara compiti specializzati per singoli utenti. Inoltre, è sensibile allo stile di ogni utente. Se due persone stavano insegnando un compito e avvenuto per dare dimostrazioni identiche, Familiar non "necessariamente deduce" programmi identici: è sintonizzato nelle loro abitudini perché impara dalla loro storia di interazione

  Familiar impiega tecniche di apprendimento standard di macchina per dedurre l'intento dell'utente. Le regole vengono utilizzate per valutare le previsioni in modo che il migliore possa essere presentato all'utente in ogni punto. Queste regole sono conditional in modo che gli utenti possano insegnare attività di classificazione quali l'ordinamento dei file in base al loro tipo e l'assegnazione di etichette in base alla loro dimensione. Si apprende in modo incrementale: l'agente si adatta a singoli utenti registrando la loro storia di interazione.

   Sono sorte molte difficoltà. Uno è la scarsità di dati. Gli utenti sono spiacevoli a dimostrare diverse iterazioni di un compito: pensano che l'agente deve immediatamente accedere a ciò che stanno facendo. Mentre un cacciatore di dati considererebbe un minuscolo set di dati a 100 cifre, gli utenti fanno parte della prospettiva di dimostrare un compito anche mezza dozzina di volte. Una seconda difficoltà è la pletora di attributi. L'ambiente desktop del computer dispone di centinaia di funzioni che potrebbero dipendere da qualsiasi azione. Ciò significa che i piccoli set di dati sono estremamente probabili irrilevanti e sono necessari test statistici specialistici per confrontare ipotesi alternative. Un terzo è che lo stile di sviluppo iterativo e migliorato che caratterizza le applicazioni di data mining non riesce. In linea di principio, è impossibile creare un corpus fisso di addestramento e test per un problema interattivo come la programmazione mediante dimostrazione perché ogni miglioramento dell'agente modifica i dati di prova influenzando il modo in cui gli utenti reagiscono.
  Un quarto è che i programmi applicativi esistenti forniscono un accesso limitato ai dati utente di applicazioni: spesso la materia prima su cui dipende l'operazione di successo è inaccessibile, sepolto profondamente all'interno del programma applicativo. La data mining è già ampiamente utilizzata sul lavoro. L'estrazione del testo inizia a portare le tecniche in questo libro nella nostra vita, mentre leggiamo la nostra e-mail e navigare sul web. Per quanto riguarda il futuro, sarà più strano di quanto possiamo immaginare. L'infrastruttura di diffusione informatica offrirà indisponibili opportunità di apprendimento. La data mining sarà lì, dietro le quinte, giocando un ruolo che si rivelerà fondamentale.
   Letture

  C'è un notevole volume di letteratura che tratta l'argomento dei massicci set di dati e possiamo solo indicare alcuni riferimenti qui. Fayyad e Smith (1995) descrivono l'applicazione di data mining a dati voluminosi da esperimenti scientifici. Shafer et al. (1996) descrivono una versione parallela di un induttore dell'albero di decisione dall'alto verso il basso. Un algoritmo di albero decisionale sequenziale per i mass-set di dati resident-disk è stato sviluppato da Mehta et al. (1996). La tecnica di applicare qualsiasi algoritmo ad un grande set di dati, suddivisi in parti più piccole e insaccando o aumentando il risultato è descritto da Breiman (1999); Frank et al. (2002) spiegano il relativo schema di potatura e selezione.

  Appelt (1999) descrive molti problemi di estrazione dell'informazione. Molti autori hanno applicato l'apprendimento delle macchine per cercare regole che estraggono slot-filler per i modelli, ad esempio Soderland et al. (1995), Huffman (1996) e Freitag (2002). Califf e Mooney (1999) e Nahm e Mooney (2000) hanno esaminato il problema dell'estrazione di informazioni da annunci di lavoro pubblicati sui newsgroup di Internet. Un approccio per trovare informazioni in esecuzione del testo basato su tecniche di compressione è stato riportato da Witten et al. (1999). Mann (1993) rileva la pletora delle variazioni di Muammar Qaddafi sui documenti ricevuti dalla Biblioteca del Congresso.
  Chakrabarti (2003) ha scritto un libro eccellente e completo sulle tecniche di estrazione Web. Kushmerick et al. (1997) sviluppò tecniche di avvolgimento involucro. Il Web semantico è stato introdotto da Tim Berners-Lee (Berners-Lee e altri, 2001), che 10 anni prima ha sviluppato la tecnologia dietro il World Wide Web.

  La prima carta sul filtraggio e-mail spazzatura è stata scritta da Sahami et al. (1998). Il nostro materiale sulla sicurezza delle reti informatiche viene eliminato dal lavoro di Yurcik et al. (2003). Le informazioni sul sistema CAPPS provengono dalla sottocommissione per l'aviazione del 2002 (Ufficio federale degli Stati Uniti) e l'uso di un apprendimento non monitorato per la rilevazione delle minacce è descritto da Bay e Schwabacher (2003). I problemi con le attuali tecniche di estrazione dei dati sulla conservazione della privacy sono state identificate da Datta et al. (2003). Stone e Veloso (2000) hanno esaminato sistemi multiagenti del genere che vengono utilizzati per giocare a robo-calcio da una prospettiva di apprendimento macchina. L'affascinante storia di Ben Ish Chai e la tecnica utilizzata per smascherarlo sono da Koppel e Schler (2004).
  La visione del calcolo calma, così come gli esempi che abbiamo menzionato, è da Weiser (1996) e Weiser e Brown (1997). Ulteriori informazioni sui diversi metodi di programmazione per dimostrazione possono essere trovati nel compendio di Cypher (1993) e Lieberman (2001). Mitchell et al. (1994) riportano qualche esperienza con apprendisti apprendimento. Familiar è descritto da Paynter (2000). Le prove di permutazione (Good 1994) sono prove statistiche adatte a piccoli problemi del campione: Frank (2000) descrive la loro applicazione nell'apprendimento della macchina.
    The Weka Machine Learning Workbench

  L'esperienza dimostra che nessun sistema di apprendimento automatico è adatto a tutti i problemi di data mining. Lo studente universale è una fantasia idealistica. Come abbiamo sottolineato in tutto questo libro, i set di dati reali variano, e per ottenere modelli precisi, la biasità dell'algoritmo di apprendimento deve corrispondere alla struttura del dominio. L'estrazione dei dati è una scienza sperimentale.
  Il banco di lavoro di Weka è una collezione di algoritmi di apprendimento di macchina all'avanguardia e strumenti di preprocessing dei dati. Esso comprende praticamente tutti gli algoritmi descritti in questo libro. È stato progettato in modo da poter provare rapidamente i metodi esistenti sui nuovi set di dati in modo flessibile. Fornisce un ampio supporto per l'intero processo di estrazione sperimentale dei dati, compresa la preparazione dei dati di input, la valutazione dei programmi di apprendimento in modo statistico e la visualizzazione dei dati di input e del risultato dell'apprendimento. Oltre ad una grande varietà di algoritmi di apprendimento, include una vasta gamma di strumenti di preprocessing. Questo toolkit diversificato e completo è accessibile attraverso un'interfaccia comune in modo che i suoi utenti possano confrontare metodi diversi e individuare quelli più appropriati per il problema in questione.

  Weka è stato sviluppato presso l'Università di Waikato in Nuova Zelanda, e il nome sta per Waikato Environment for Knowledge Analysis. All'esterno dell'università la weka, pronunziata alla rima con la Mecca, è un uccello volatili con una natura curiosa che si trova solo sulle isole della Nuova Zelanda. Il sistema è scritto in Java e distribuito sotto i termini della GNU General Public License. Funziona su quasi tutte le piattaforme e è stato testato in sistemi operativi Linux, Windows e Macintosh e persino su un assistente digitale personale. Fornisce un'interfaccia uniforme per molti diversi algoritmi di apprendimento, insieme ai metodi per la pre- e postprocessing e per la valutazione del risultato di schemi di apprendimento su un dato set di dati.
    What’s in Weka?

  Weka fornisce implementazioni di algoritmi di apprendimento che si possono applicare facilmente al tuo set di dati. Esso comprende inoltre una serie di strumenti per la trasformazione di set di dati, ad esempio gli algoritmi per la discretizzazione descritti nel Capitolo 7. È possibile preprocessare un set di dati, alimentarlo in un schema di apprendimento e analizzare il classificatore risultante e la sua prestazione - tutto senza scrivere alcun codice di programma affatto.
    Il banco di lavoro comprende metodi per tutti i problemi di minima data minima: la regressione, la classificazione, il clustering, l'associazione delle regole di associazione e la selezione degli attributi. Conoscere i dati è parte integrante del lavoro e sono disponibili molti strumenti di visualizzazione dei dati e strumenti di preprocessing dei dati. Tutti gli algoritmi prendono il loro ingresso sotto forma di una singola tabella relazionale nel formato ARFF descritto nella sezione 2.4, che può essere letto da un file o generato da una query di database.

  Un modo per utilizzare Weka è quello di applicare un metodo di apprendimento a un set di dati e di analizzare la propria output per ulteriori informazioni sui dati. Un altro è utilizzare modelli appresi per generare previsioni su nuove istanze. Un terzo è quello di applicare diversi discenti differenti e di confrontare le loro prestazioni per scegliere uno per la previsione. I metodi di apprendimento sono chiamati classificatori e nell'interfaccia Weka interattiva è possibile selezionare quello desiderato da un menu. Molti classificatori hanno parametri sintonizzabili, che accedete tramite un editor delle proprietà o di un oggetto. Un modulo di valutazione comune viene utilizzato per misurare le prestazioni di tutti i classificatori.
  Le implementazioni dei programmi di apprendimento reali sono la risorsa più preziosa che Weka fornisce. Ma gli strumenti per la preprocessazione dei dati, denominati filtri, sono un secondo passo. Come i classificatori, seleziona i filtri da un menu e li adatta alle tue esigenze. Mostreremo come possono essere usati diversi filtri, elencare gli algoritmi di filtraggio e descrivere i loro parametri. Weka include anche implementazioni di algoritmi per regole di associazione di apprendimento, cluster di dati per i quali non è specificato alcun valore di classe e la selezione di attributi rilevanti nei dati, che descriviamo brevemente.
      Come lo usi? - How do you use it?

  Il modo più semplice per utilizzare Weka è attraverso un'interfaccia grafica chiamata Explorer. Questo consente di accedere a tutte le sue strutture utilizzando la selezione dei menu e il riempimento di moduli. Ad esempio, è possibile leggere rapidamente in un set di dati da un file ARFF (o foglio di calcolo) e creare un albero di decisione da esso. Ma gli alberi decisionali di apprendimento sono solo l'inizio: ci sono molti altri algoritmi da esplorare. L'interfaccia Explorer ti aiuta a fare proprio questo. Esso vi guiderà presentando le scelte come menu, obbligandovi a lavorare in un ordine appropriato, utilizzando le opzioni finché non sono applicabili e presentando le opzioni come moduli da compilare. Suggerimenti utili sugli strumenti vengono visualizzati quando il mouse passa sopra gli elementi sullo schermo per spiegare ciò che fanno. Valori predefiniti sensibili assicurano che è possibile ottenere risultati con un minimo di sforzo, ma dovrai pensare a quello che stai facendo per capire quali sono i risultati.

   Ci sono altre due interfacce utente grafiche a Weka. L'interfaccia Knowledge Flow consente di progettare configurazioni per l'elaborazione dati in streaming. Uno svantaggio fondamentale dell'Explorer è che tiene tutto nella memoria principale: quando si apre un set di dati, esso lo carica immediatamente. Ciò significa che può essere applicato solo a piccole e medie dimensioni. Tuttavia, Weka contiene alcuni algoritmi incrementali che possono essere utilizzati per elaborare set di dati molto grandi. L'interfaccia Knowledge Flow consente di trascinare le caselle che rappresentano algoritmi di apprendimento e fonti di dati attorno allo schermo e unirle insieme nella configurazione desiderata. Consente di specificare un flusso di dati collegando componenti che rappresentano fonti dati, strumenti di preprocessing, algoritmi di apprendimento, metodi di valutazione e moduli di visualizzazione. Se i filtri e gli algoritmi di apprendimento sono abilitati al apprendimento incrementale, i dati verranno caricati e elaborati in modo incrementale.

  La terza interfaccia di Weka, il Experimenter, è progettata per aiutarti a rispondere a una domanda pratica fondamentale applicando tecniche di classificazione e regressione: quali metodi e valori dei parametri funzionano meglio per il problema specifico? Di solito non c'è modo di rispondere a priori a questa domanda, e un motivo per cui abbiamo sviluppato il banco di lavoro è stato quello di fornire un ambiente che consente agli utenti Weka di confrontare una varietà di tecniche di apprendimento. Ciò può essere fatto interattivamente utilizzando l'Explorer. Tuttavia, Experimenter consente di automatizzare il processo facendo semplificare l'esecuzione di classificatori e filtri con impostazioni di parametri differenti su un corpus di set di dati, raccogliere statistiche sulle prestazioni e eseguire test di significato. Gli utenti avanzati possono utilizzare il Experimenter per distribuire il carico di calcolo su più macchine utilizzando invocazione Java remoto di metodo (RMI). In questo modo è possibile impostare esperimenti statistici su larga scala e lasciarli eseguire.

  Dietro queste interfacce interattive risiede la funzionalità di base di Weka. È possibile accedere in forma grezzo inserendo comandi testuali, che consente l'accesso a tutte le funzionalità del sistema. Quando si accende Weka, è necessario scegliere tra quattro diverse interfacce utente: l'Explorer, il Flusso di conoscenza, l'Experimenter e l'interfaccia della riga di comando. Le descriveremo a turno nei prossimi capitoli. La maggior parte delle persone sceglie l'Explorer, almeno all'inizio.
   Cosa altro posso fare? - What else can you do?

  Una risorsa importante quando si lavora con Weka è la documentazione in linea, generata automaticamente dal codice sorgente e sinteticamente riflette la sua struttura. Spiegheremo come utilizzare questa documentazione e come identificare i principali elementi di base di Weka, evidenziando quali parti contengono metodi di apprendimento supervisionati che contengono strumenti per la preprocessing dei dati e che contengono metodi per altri schemi di apprendimento. Dà l'unico elenco completo di algoritmi disponibili perché Weka è in continua crescita e viene generato automaticamente dal codice sorgente - la documentazione in linea è sempre aggiornata. Inoltre, diventa essenziale se si desidera procedere al livello successivo e accedere alla libreria dai propri programmi Java o scrivere e testare i propri schemi di apprendimento.

  Nella maggior parte delle applicazioni di data mining, il componente di apprendimento macchina è solo una piccola parte di un sistema software molto più grande. Se si intende scrivere un'applicazione di data mining, si desidera accedere ai programmi in Weka dall'interno del proprio codice. In questo modo, è possibile risolvere il sottoproblema di apprendimento macchina dell'applicazione con un minimo di programmazione aggiuntiva. Vi mostriamo come farlo presentando un esempio di un'applicazione semplice di data mining in Java. Ciò consente di familiarizzare con le strutture di base di dati in Weka, rappresentando istanze, classificatori e filtri.
  Se intendi diventare un esperto in algoritmi di apprendimento macchina (o, in verità, se sei già uno), probabilmente vuoi implementare i tuoi algoritmi senza dover affrontare tali dettagli fondamentali come la lettura dei dati da un file, implementando il filtraggio Algoritmi o fornire codice per valutare i risultati. Se è così, abbiamo buone notizie per te: Weka include già tutto questo. Per usufruire del tutto, è necessario conoscere le strutture di base di dati. Per aiutarti a raggiungere questo punto, descriveremo in modo più dettagliato queste strutture e spiegheremo un'implementazione illustrativa di un classificatore.
   Come lo fai? - How do you get it?

  Weka è disponibile da http://www.cs.waikato.ac.nz/ml/weka. È possibile scaricare sia un programma di installazione specifico per la piattaforma che un file jar eseguibile Java eseguito nel modo più abituale se è installato Java. Ti consigliamo di scaricare e installarlo ora e seguire gli esempi nelle prossime sezioni.
    The Explorer

  L'interfaccia grafica principale di Weka, l'Explorer, consente l'accesso a tutte le sue strutture utilizzando la selezione dei menu e il riempimento di moduli. Viene illustrato in Figura 10.1. Ci sono sei diversi pannelli, selezionati dalle schede in alto, corrispondenti alle varie attività di data mining che Weka supporta.

     Getting started
  Supponi di avere dei dati e vuoi costruire un albero di decisione da esso. Innanzitutto, è necessario preparare i dati, quindi attivare Esplora risorse e caricare i dati. Successivamente seleziona un metodo di costruzione dell'albero di decisione, crea un albero e interpreta l'output. È facile farlo di nuovo con un diverso algoritmo di costruzione degli alberi o un diverso metodo di valutazione. Nell'Explorer puoi passare avanti e indietro tra i risultati ottenuti, valutare i modelli che sono stati costruiti su set di dati diversi e visualizzare graficamente sia i modelli che i set di dati, inclusi gli eventuali errori di classificazione che i modelli fanno.
   Preparing the data

  I dati vengono spesso presentati in un foglio di calcolo o database. Tuttavia, il metodo di archiviazione dati nativa di Weka è il formato ARFF (sezione 2.4). È possibile convertire facilmente da un foglio di calcolo in ARFF. La maggior parte di un file ARFF consiste di un elenco delle istanze ei valori degli attributi per ogni istanza sono separati da virgole (Figura 2.2). La maggior parte dei programmi fogli di calcolo e dei database consente di esportare i dati in un file in formato con virgola separata (CSV) come un elenco di record con virgole tra gli elementi. Una volta fatto questo, è sufficiente caricare il file in un editor di testo o un elaboratore di testi; Aggiungere il nome del set di dati utilizzando il tag @relation, le informazioni sugli attributi utilizzando @attribute e una riga @data; E salvare il file come testo grezzo. Ad esempio, la Figura 10.2 mostra un foglio di calcolo di Excel contenente i dati meteo della sezione 1.2, i dati in formato CSV caricati in Microsoft Word e il risultato della conversione manualmente in un file ARFF. Tuttavia, in realtà non è necessario eseguire questi passaggi per creare il file ARFF, perché l'Explorer può leggere direttamente i file del foglio di calcolo CSV, come descritto più avanti.
     Loading the data into the Explorer

  Carichiamo questi dati nell'Explorer e iniziamo ad analizzarlo. Spara Weka per ottenere il pannello mostrato nella Figura 10.3 (a). Seleziona Explorer dalle quattro scelte grafiche dell'interfaccia utente nella parte inferiore. (Gli altri sono stati menzionati in precedenza: il CLI semplice è l'interfaccia a riga di comando di vecchio stile).
  Quello che vedete dopo è la schermata Explorer principale, mostrata nella Figura 10.3 (b). In realtà, la figura mostra come apparirà dopo aver caricato i dati meteo. Le sei schede lungo la parte superiore sono le operazioni di base che l'Explorer supporta: ora siamo in Preprocesso. Fare clic sul pulsante Apri file per visualizzare una finestra di dialogo standard tramite cui è possibile selezionare un file. Scegli il file weather.arff. Se lo si dispone in formato CSV, passare da file di dati ARFF a file di dati CSV. Quando si specifica un file .csv viene automaticamente convertito in formato ARFF.

  Dopo aver caricato il file, lo schermo sarà come mostrato nella Figura 10.3 (b). Questo ti dice sul set di dati: dispone di 14 istanze e cinque attributi (centro a sinistra); Gli attributi sono chiamati outlook, temperatura, umidità, ventosa e gioco (in basso a sinistra). Il primo attributo, outlook, viene selezionato per impostazione predefinita (è possibile scegliere altri facendo clic su di essi) e non dispone di valori mancanti, tre valori distinti e nessun valore univoco; I valori effettivi sono soleggiati, coperti e piovosi e si verificano rispettivamente cinque, quattro e cinque volte (a destra centrale). Un istogramma in basso a destra mostra quanto spesso ognuno dei due valori della classe gioca, si verifica per ogni valore dell'attributo di outlook. L'outlook attributo viene utilizzato perché appare nella casella sopra l'istogramma, ma è possibile disegnare un istogramma di qualsiasi altro attributo. Qui il gioco è selezionato come attributo di classe; Viene utilizzato per colorare l'istogramma e tutti i filtri che richiedono un valore di classe lo utilizzano.

  L'attributo di outlook in Figura 10.3 (b) è nominale. Se si seleziona un attributo numerico, vengono visualizzati i valori minimi e massimi, la media e la deviazione standard. In questo caso l'istogramma mostrerà la distribuzione della classe come funzione di questo attributo (un esempio viene visualizzato in Figura 10.9 a pagina 384).
   È possibile eliminare un attributo facendo clic sulla relativa casella di controllo e utilizzando il pulsante Rimuovi. Tutti seleziona tutti gli attributi, Nessuno seleziona nessuno e Inverti inverte la selezione corrente. Puoi annullare una modifica facendo clic sul pulsante Annulla. Il pulsante Modifica visualizza un editor che consente di ispezionare i dati, cercare determinati valori e modificarli ed eliminare istanze e attributi. Facendo clic con il pulsante destro sui valori e sulle intestazioni di colonna, vengono visualizzati i menu contestuali corrispondenti.
   Building a decision tree

  Per vedere che cosa lo studente di albero di decisione C4.5 descritto nella sezione 6.1 fa con questo set di dati, utilizza l'algoritmo J4.8, che è l'implementazione di Weka di questo utente di albero decisionale. (J4.8 effettua effettivamente una versione successiva e leggermente migliorata denominata C4.5 revision 8, che era l'ultima versione pubblica di questa famiglia di algoritmi prima dell'uscita della versione commerciale C5.0). Fare clic sulla scheda Classifica per ottenere uno schermo che Sembra Figura 10.4 (b). In realtà, la figura mostra che cosa apparirà dopo aver analizzato i dati meteo.
   Seleziona prima il classificatore facendo clic sul pulsante Scegli in alto a sinistra, aprendo la sezione alberi del menu gerarchico in Figura 10.4 (a) e trovando J48. La struttura del menu rappresenta l'organizzazione del codice Weka in moduli, che saranno descritti nel capitolo 13. Per ora, apri semplicemente la gerarchia come necessario: gli elementi da selezionare sono sempre al livello più basso. Una volta selezionato, J48 viene visualizzato nella riga accanto al pulsante Scegli come mostrato in Figura 10.4 (b), insieme ai valori dei parametri predefiniti. Se si sceglie tale riga, l'editor di oggetti del classificatore J4.8 si apre e si può vedere quali parametri significano e modificare i loro valori se lo si desidera. L'Explorer sceglie generalmente i valori predefiniti sensibili.

Dopo aver scelto il classificatore, invocarlo facendo clic sul pulsante Start. Weka lavora per un breve periodo - quando sta lavorando, l'uccellino in basso a destra della figura 10.4 (b) salta e balla - e produce quindi l'uscita mostrata nel pannello principale di Figura 10.4 (b).
   Examining the output

 La Figura 10.5 mostra l'output completo (Figura 10.4 (b) fornisce solo la metà inferiore). All'inizio è un riepilogo del set di dati e il fatto che è stata utilizzata una convalida incrociata dieci volte per valutarla. Questo è l'impostazione predefinita e se si guarda attentamente alla figura 10.4 (b) vedrai che la casella di convalida incrociata a sinistra è selezionata. Poi viene un albero di decisione pruned in forma testuale. La prima divisione è sull'attributo di outlook e quindi, al secondo livello, le suddivisioni sono rispettivamente sull'umidità e sul vento. Nella struttura ad albero, un colon introduce l'etichetta di classe assegnata a una particolare foglia, seguita dal numero di istanze che raggiungono quella foglia, espresse come numero decimale, a causa del modo in cui l'algoritmo utilizza istanze frazionarie per gestire i valori mancanti. Se c'erano istanze erroneamente classificate (non ci sono in questo esempio) il loro numero apparirà anche: così 2.0 / 1.0 significa che due istanze hanno raggiunto quella foglia, di cui uno è classificato in modo errato. Sotto la struttura ad albero viene stampato il numero di foglie; Quindi il numero totale di nodi (dimensione dell'albero). C'è un modo per visualizzare più graficamente gli alberi decisionali: vedere pagine 378-379 più avanti in questo capitolo.

  La parte successiva dell'output fornisce stime della prestazione predittiva dell'albero. In questo caso vengono ottenuti con una convalida incrociata stratificata con 10 pieghe, il valore predefinito in Figura 10.4 (b). Come si può vedere, più del 30% delle istanze (5 su 14) sono state classificate in modo errato nella convalida incrociata. Ciò indica che i risultati ottenuti dai dati di addestramento sono ottimisti rispetto a quanto potrebbe essere ottenuto da un test indipendente proveniente dalla stessa sorgente. Dalla matrice di confusione alla fine (descritta nella sezione 5.7) osservare che 2 istanze di classe sì sono state assegnate alla classe no e 3 della classe no sono assegnate alla classe sì.
   Oltre all'errore di classificazione, il modulo di valutazione esegue anche la statistica di Kappa (Sezione 5.7), l'errore assoluto medio e l'errore medio-quadrato di root delle stime della probabilità di classe assegnate dall'albero. L'errore medio quadrato di root è la radice quadrata della perdita quadratica media (sezione 5.6). L'errore assoluto medio viene calcolato in modo simile utilizzando l'assoluto invece della differenza quadrata. Esso inoltre emette errori relativi, che si basano sulle probabilità precedenti (cioè quelle ottenute dallo schema di apprendimento ZeroR descritto più avanti). Infine, per ogni classe viene anche in uscita alcune statistiche da pagina 172.
   Fallo ancora - Doing it again

 Puoi facilmente eseguire nuovamente J4.8 con un metodo di valutazione diverso. Selezionare Utilizza set di formazione (vicino alla parte superiore sinistra della Figura 10.4 (b)) e fare nuovamente clic su Avvia. L'uscita del classificatore viene sostituita rapidamente per mostrare quanto il modello derivato esegue sul set di formazione, anziché mostrare i risultati delle convalida incrociate. Questa valutazione è altamente ottimista (Sezione 5.1). Può comunque essere utile, perché rappresenta generalmente un limite superiore alla performance del modello su dati freschi. In questo caso, tutte le 14 istanze di formazione sono classificate correttamente. In alcuni casi un classificatore può decidere di lasciare alcuni casi non classificati, nel qual caso questi saranno elencati come istanze non classificate. Questo non avviene per la maggior parte dei sistemi di apprendimento in Weka.
  Il pannello di Figura 10.4 (b) presenta ulteriori opzioni di test: il set di test fornito, in cui si specifica un file separato contenente il set di test e la suddivisione in percentuale con la quale è possibile tenere una determinata percentuale dei dati da testare. Puoi pubblicare le previsioni per ogni istanza facendo clic sul pulsante Ulteriori opzioni e controllando la voce appropriata. Ci sono altre opzioni utili, come la soppressione di alcuni risultati e le altre statistiche, come le misure di valutazione dell'entropia e la valutazione dei costi. Per quest'ultima è necessario immettere una matrice di costi: digitare il numero di classi nella casella Classi (e terminare con il tasto Invio o Indietro) per ottenere una matrice di costo predefinita (Sezione 5.7), quindi modificare i valori come richiesto.
   Il piccolo riquadro in basso a sinistra della figura 10.4 (b), che contiene una riga evidenziata, è un elenco di cronologia dei risultati. L'Explorer aggiunge una nuova riga ogni volta che si esegue un classificatore. Poiché è ora eseguito due volte il classificatore, l'elenco contiene due elementi. Per tornare a un set di risultati precedente, fare clic sulla riga corrispondente e l'output di tale esecuzione apparirà nel riquadro di output del classificatore. Ciò consente di esplorare diversi classificatori o schemi di valutazione e rivisitare i risultati per confrontarli.
    Working with models

  L'elenco di cronologia dei risultati è il punto di accesso a alcune potenti funzionalità dell'Explorer. Quando si fa clic con il pulsante destro del mouse su una voce, viene visualizzato un menu che consente di visualizzare i risultati in una finestra separata oppure salvare il buffer di risultati. Ancora più importante, è possibile salvare il modello che Weka ha generato sotto forma di un file di oggetto Java. È possibile ricaricare un modello che è stato salvato in precedenza, che genera una nuova voce nell'elenco dei risultati. Se si fornisce ora un set di test, è possibile rivalutare il vecchio modello di quel nuovo set.
  Diversi elementi nel menu di scelta rapida consentono di visualizzare i risultati in vari modi. Nella parte superiore dell'interfaccia Esplora è una scheda Visualizzazione separata, ma è diversa: mostra il set di dati, non i risultati di un determinato modello. Facendo clic con il pulsante destro del mouse su una voce nell'elenco di cronologia, è possibile visualizzare gli errori del classificatore. Se il modello è un albero o una rete Bayesiana puoi vedere la sua struttura. È inoltre possibile visualizzare la curva di margine (pagina 324) e varie curve di costo e di soglia (sezione 5.7). Per le curve di costo e di soglia è necessario scegliere un valore di classe da un sottomenu. La voce di menu della curva di soglia di visualizzazione consente di visualizzare l'effetto di variare la soglia di probabilità sopra la quale viene assegnata un'istanza a quella classe. È possibile scegliere tra un'ampia varietà di curve che includono le curve di ROC e di richiamo di precisione (tabella 5.7). Per vedere questi, scegliere gli assi X e Y in modo appropriato dai menu forniti. Ad esempio, impostato su false tasso X positivo e Y per tasso positivo True per una curva ROC di richiamare o X e Y per precisione per una curva di richiamo precisione.

   La Figura 10.6 mostra due modi per esaminare il risultato dell'utilizzo di J4.8 per classificare il set di dati Iris (Sezione 1.2). Utilizziamo questo, piuttosto che i dati meteo, perché produce immagini più interessanti. La figura 10.6 (a) mostra l'albero. Fare clic con il pulsante destro del mouse su uno spazio vuoto in questa finestra per visualizzare un menu che consente di scalare automaticamente la visualizzazione o di forzare l'albero nella finestra. Trascinate il mouse per spostarsi nello spazio. È inoltre possibile visualizzare i dati di istanza in qualsiasi nodo, se è stato salvato dall'algoritmo di apprendimento.
   La Figura 10.6 (b) mostra gli errori del classificatore su una trama bidimensionale. È possibile scegliere quali attributi da utilizzare per X e Y utilizzando le caselle di selezione in alto. In alternativa, fare clic su una delle righe orizzontali punteggiate a destra della trama: fare clic con il pulsante sinistro per X e fare clic con il pulsante destro del mouse per Y. Ogni striscia mostra la diffusione di istanze lungo tale attributo. X e Y si visualizzano accanto a quelli scelti per gli assi.I punti dati sono colorati secondo la loro classe: blu, rosso e verde per Iris setosa, Iris versicolor e Iris virginica, rispettivamente (c'è una chiave nella parte inferiore dello schermo). Istanze classificate correttamente sono mostrate come croci; Quelli classificati in modo errato appaiono come scatole (di cui tre sono riportate nella Figura 10.6 (b)). È possibile fare clic su un'istanza per visualizzare dettagli pertinenti: il numero di istanza, i valori degli attributi, la classe e la classe prevista.
   Quando le cose vanno male - When things go wrong

  Sotto l'elenco della cronologia dei risultati, in fondo alla figura 10.4 (b), è una riga di stato che dice semplicemente OK. Occasionalmente, questo cambia in Visualizza log di errori, un'indicazione che qualcosa è andato storto. Ad esempio, possono esistere vincoli tra le varie selezioni differenti che puoi fare in un pannello. Per la maggior parte dell'intervallo, l'interfaccia rileva selezioni inadeguate e rifiuta di farti scegliere. Ma a volte le interazioni sono più complesse e si può finire per selezionare una serie incompatibile di opzioni. In questo caso, la linea di stato cambia quando Weka scopre l'incompatibilità, in genere quando si preme Start. Per visualizzare l'errore, fai clic sul pulsante Registra a sinistra della weka nell'angolo inferiore destro dell'interfaccia.


 Figure 10.6 Visualizing the result of J4.8 on the iris dataset: (a) the tree and (b) the classifier errors.
     Exploring the Explorer

 Abbiamo analizzato brevemente due delle sei schede nella parte superiore della finestra Esplora in Figura 10.3 (b) e Figura 10.4 (b). In sintesi, ecco cosa fanno tutte le schede:
1. Preprocesso: scegliere il set di dati e modificarlo in diversi modi.
2. Classificare: programmi di apprendimento del treno che eseguono la classificazione o la regressione e li valutano.
3. Cluster: impara cluster per il set di dati.
4. Associate: Imparare le regole di associazione per i dati e valutarle.
5. Selezionare gli attributi: selezionare gli aspetti più rilevanti nel set di dati.
6. Visualizzare: visualizzare le diverse piattaforme bidimensionali dei dati e interagire con loro.


 Ogni scheda offre l'accesso a una vasta gamma di strutture. Nel nostro tour finora, abbiamo appena graffiato la superficie dei pannelli Preprocess e Classify. Nella parte inferiore di ogni pannello è una casella di stato e un pulsante Registro. La casella di stato visualizza i messaggi che ti informano su cosa sta succedendo. Ad esempio, se l'Explorer è occupato a caricare un file, la casella di stato lo dirà. Facendo clic con il pulsante destro del mouse ovunque all'interno di questa casella viene visualizzato un piccolo menu con due opzioni: visualizzare la quantità di memoria disponibile per Weka e eseguire il collettore di rifiuti Java. Tieni presente che il collettore di rifiuti funziona costantemente come un compito di sfondo comunque.
   Facendo clic sul pulsante Registro apre un registro testuale delle azioni che Weka ha eseguito in questa sessione, con timestamp. Come indicato in precedenza, l'uccellino in basso a destra della finestra salta e balla quando Weka è attivo. Il numero accanto al ¥ indica quanti processi concorrenti sono in esecuzione. Se l'uccello sta in piedi ma smette di muoversi, è malato! Qualcosa è andato storto e si dovrebbe riavviare l'Explorer.
 Caricamento e filtraggio di file

Al di là della parte superiore del pannello Preprocess in Figura 10.3 (b) sono i pulsanti per l'apertura di file, URL e database. Inizialmente, solo i file i cui nomi finiscono in .arff appaiono nel browser di file; Per vedere altri, modificare l'elemento Formato nella casella di selezione dei file.
  Conversione di file in ARFF

Weka dispone di tre convertitori di file: per i file di foglio di calcolo con l'estensione .csv, per il formato di file nativo C4.5 con le estensioni .names e .data e per le istanze serializzate con l'estensione .bsi. Il convertitore appropriato viene utilizzato in base all'estensione. Se Weka non può caricare i dati, tenta di interpretarlo come ARFF. Se ciò non riesce, si apre la casella mostrata nella Figura 10.7 (a).

 

 Figure 10.7 Generic object editor


  Si tratta di un editor di oggetti generici, utilizzato in Weka per la selezione e la configurazione di oggetti. Ad esempio, quando si impostano parametri per un classificatore, si utilizza lo stesso tipo di casella. Il file CSVLoader per i file .csv è selezionato per impostazione predefinita e il pulsante Altro fornisce ulteriori informazioni, illustrate nella Figura 10.7 (b). Vale sempre la pena di guardare la documentazione! In questo caso, spiega che la prima riga del foglio di calcolo determina i nomi degli attributi. Fare clic su OK per utilizzare questo convertitore. Per un altro, fai clic su Scegli per selezionare dall'elenco di Figura 10.7 (c).
  L'ArffLoader è la prima opzione e abbiamo raggiunto questo punto solo perché non è riuscito. Il CSVLoader è l'impostazione predefinita e abbiamo scelto Scegli perchè vogliamo un altro. La terza opzione è per il formato C4.5, in cui ci sono due file per un set di dati, uno che fornisce nomi di campo e l'altro fornisce i dati reali. La quarta, per le istanze serializzate, è quella di ricaricare un set di dati che è stato salvato come oggetto serializzato Java. Tutto l'oggetto Java può essere salvato in questo modulo e ricaricato. Come formato Java nativo, è più veloce da caricare di un file ARFF, che deve essere analizzato e controllato. Quando ripetutamente ricaricando un grande set di dati, potrebbe essere utile risparmiare tale forma.

   Ulteriori funzionalità dell'editor oggetti generico in Figura 10.7 (a) sono Salva, che salva un oggetto configurato e Apri, che apre un file salvato in precedenza. Questi non sono utili per questo particolare tipo di oggetto. Ma altri pannelli generici dell'editor di oggetti hanno molte proprietà modificabili, e dopo aver risolto alcuni problemi per impostarli, è possibile salvare l'oggetto configurato per riutilizzarlo in un secondo momento. I file sul tuo computer non sono l'unica fonte di set di dati per Weka. È possibile aprire un URL e Weka utilizzerà il protocollo di trasferimento ipertestuale (HTTP) per scaricare un file ARFF dal Web. Oppure è possibile aprire un database (DB aperto) - qualsiasi database con un driver Java connettività (JDBC) - e recuperare le istanze utilizzando l'istruzione SQL Select. Questo restituisce una relazione che Weka legge come un file ARFF. Per fare questo lavoro con il tuo database, potrebbe essere necessario modificare il file weka / experiment / DatabaseUtils.props nella distribuzione Weka aggiungendo il proprio driver di database. (Per accedere a questo file, espandere il file weka.jar nella distribuzione Weka.) I dati possono essere salvati in tutti questi formati utilizzando il pulsante Salva nella Figura 10.3 (b). Oltre a caricare e salvare i set di dati, il pannello Preprocess consente anche di filtrarli. I filtri sono una componente importante di Weka.
   Using filters

 Facendo clic su Scegli (vicino alla parte superiore sinistra) nella Figura 10.3 (b) viene fornito un elenco di filtri come quello riportato nella Figura 10.8 (a). In realtà, hai una versione collassata: fai clic su una freccia per aprire il contenuto. Descriveremo come utilizzare un semplice filtro per eliminare gli attributi specificati da un set di dati, ovvero per eseguire la selezione degli attributi manuali. Lo stesso effetto può essere ottenuto più facilmente selezionando i relativi attributi utilizzando le caselle di spunta e premendo il pulsante Rimuovi. Tuttavia, come esempio, descriviamo esplicitamente l'operazione di filtraggio equivalente.

  'Remove' è un filtro di attributo non supervisionato e per vederlo devi scorrere ulteriormente nell'elenco. Quando è selezionato, appare nella riga accanto al pulsante Scegli, insieme ai valori dei parametri, in questo caso la riga legge semplicemente "Rimuovi". Clicca su quella riga per visualizzare un generico oggetto editor con cui è possibile esaminare e modificare le proprietà del filtro . (È stata eseguita la stessa cosa in precedenza facendo clic sulla riga J48 in Figura 10.4 (b) per aprire l'editor di oggetti del classificatore J4.8.) L'editor di oggetti per il filtro Rimuove è mostrato nella Figura 10.8 (b). Per saperne di più, fare clic su Altro per visualizzare le informazioni in Figura 10.8 (c). Ciò spiega che il filtro elimina una serie di attributi dal set di dati. Ha un'opzione, attributeIndices, che specifica l'intervallo da agire e un altro chiamato invertSelection che determina se il filtro seleziona gli attributi o li elimina. Ci sono scatole per entrambi nell'editor di oggetto mostrato nella Figura 10.8 (b) e infatti li abbiamo già impostati a 1,2 (per influenzare gli attributi 1 e 2, ovvero la prospettiva e la temperatura) e False (per rimuovere Piuttosto che trattenermi). Fare clic su OK per impostare queste proprietà e chiudere la casella. Si noti che la riga accanto al pulsante Scegli ora legge Remove -R 1,2. Nella versione della riga di comando del filtro Rimuovi, l'opzione -R viene utilizzata per specificare gli attributi da rimuovere. Dopo aver configurato un oggetto, è spesso degno di dare un'occhiata alla formulazione della riga di comando risultante che l'Explorer imposta.

  Applicare il filtro facendo clic su Applica (sul lato destro della Figura 10.3 (b)). Appena appare lo schermo della Figura 10.9, come quello della Figura 10.3 (b) ma con solo tre attributi, umidità, ventosa e riproduzione. A questo punto viene attivato il quarto pulsante della riga vicino alla parte superiore. Undo inverte l'operazione di filtraggio e ripristina il set di dati originale, utile quando si sperimentano diversi filtri.
   Viene selezionato il primo attributo, l'umidità, e una sintesi dei suoi valori appare sulla destra. Come attributo numerico vengono visualizzati i valori minimi e massimi, la media e la deviazione standard. Di seguito è riportato un istogramma che mostra la distribuzione dell'attributo play. Purtroppo, questo display è impoverito perché l'attributo ha pochissimi valori diversi che cadono in due contenitori di dimensioni uguali. I set di dati più realistici producono istogrammi più informativi.


Figure 10.9 The weather data with two attributes removed.
     Training and testing learning schemes

Il pannello Classify consente di formare e testare schemi di apprendimento che eseguono la classificazione o la regressione. La sezione 10.1 ha spiegato come interpretare l'output di un utente di un albero di decisione e ha mostrato le figure di prestazioni generate automaticamente dal modulo di valutazione. L'interpretazione di questi è la stessa per tutti i modelli che prevedono una classe categorica. Tuttavia, quando valuta i modelli per la previsione numerica, Weka produce un diverso set di misure di prestazioni.
   Ad esempio, in Figura 10.10 (a) il set di dati della performance della CPU da Tabella 1.5 (pagina 16) è stato caricato in Weka. È possibile visualizzare l'istogramma dei valori del primo attributo, venditore, in basso a destra. Nella figura 10.10 (b) l'agente di modello M5 ¢ è stato scelto come classificatore passando al riquadro Classify, facendo clic sul pulsante Scegli in alto a sinistra, aprendo la sezione alberi del menu gerarchico mostrato nella figura 10.4 (a) , Trovando M5P e facendo clic su Avvia. La gerarchia consente di individuare classificatori particolari raggruppando elementi con funzionalità comuni.

  La Figura 10.11 mostra l'output. L'albero del modello di potatura è semplicemente un pezzo di decisione con una divisione dell'attributo MMAX e due modelli lineari, uno per ciascuna foglia. Entrambi i modelli coinvolgono un attributo nominale, un fornitore, così come alcuni numerici. L'espressione fornitore = consulente, sperry, amdahl è interpretato come segue: se il venditore è consulente, spero o amdahl, quindi sostituisce 1; Altrimenti, sostituire 0. La descrizione dell'albero del modello è seguita da diverse figure che misurano la sua performance. Questi sono derivati ​​dall'opzione di prova scelta in Figura 10.10 (b), convalida incrociata a 10 volte (non stratificata, perché ciò non ha senso per la previsione numerica). La sezione 5.8 (Tabella 5.8) spiega il significato delle varie misure.
  La regressione lineare ordinaria (sezione 4.6), un altro schema per la previsione numerica, si trova nella LinearRegression nella sezione delle funzioni del menu in Figura 10.4 (a). Costruisce un unico modello di regressione lineare piuttosto che i due in Figura 10.11; Non sorprende che la sua performance è leggermente peggiore.
  Per ottenere una sensazione per la loro performance relativa, visualizziamo gli errori che questi schemi fanno, come abbiamo fatto per il dataset di Iris in Figura 10.6 (b). Fare clic con il pulsante destro della voce nell'elenco di cronologia e selezionare Visualizzare gli errori del classificatore per visualizzare la trama bidimensionale dei dati nella Figura 10.12. I punti sono codificati in colore dalla classe - ma in questo caso il colore varia continuamente perché la classe è numerica. Nella Figura 10.12 è stato selezionato l'attributo Vendor per l'asse X e il numero dell'istanza è stato scelto per l'asse Y, in quanto ciò consente una buona diffusione dei punti. Ogni punto dati è contrassegnato da una croce la cui dimensione indica il valore assoluto dell'errore per tale istanza. Le più piccole croci in Figura 10.12 (a) (per M5 ¢), rispetto a quelle della Figura 10.12 (b) (per la regressione lineare), mostrano che M5 ¢ è superiore.


  Figure 10.12 Visualizing the errors:
   Do it yourself: The User Classifier

  Il classificatore utente (menzionato alla fine della sezione 3.2) consente agli utenti di Weka di costruire interattivamente i propri classificatori. Esso risiede nella sezione alberi del menu gerarchico di Figura 10.4 (a) in UserClassifier. Illustriamo il suo funzionamento su un nuovo problema, segmentando i dati visivi di immagine in classi come l'erba, il cielo, il fogliame, il mattone e il cemento in base a attributi che forniscono intensità, tonalità, dimensione, posizione e varie semplici caratteristiche strutturali. Il file di formazione è fornito con la distribuzione di Weka e denominato "segment-challenge.arff". Dopo averlo caricato, seleziona il classificatore utente. Per la valutazione utilizzare il set di test speciale chiamato segmenttest.arff come il test fornito impostato nel pannello Classify. La valutazione mediante la convalida incrociata è impossibile quando si deve costruire manualmente un classificatore per ogni piega.

  Dopo l'avvio, appare una nuova finestra e Weka ti aspetta di costruire il classificatore. Le schede Tree Visualizer e Data Visualizer passano da una vista diversa. Il primo mostra lo stato corrente dell'albero di classificazione e ogni nodo fornisce il numero di istanze di ogni classe in quel nodo. Lo scopo è quello di trovare un albero in cui i nodi delle foglie siano il più puro possibile. Inizialmente c'è solo un nodo, la radice, che contiene tutti i dati. Passare al Data Visualizer per creare una divisione. Ciò mostra la stessa trama bidimensionale che abbiamo visto in Figura 10.6 (b) per il dataset Iris e la Figura 10.12 per i dati sulle prestazioni della CPU. Gli attributi da utilizzare per X e Y sono selezionati come prima, e l'obiettivo qui è quello di trovare una combinazione che separa le classi il più possibile pulite. La Figura 10.13 (a) mostra una buona scelta: 'region-centroid-row' per X e intensità media per Y.
   Dopo aver trovato una buona separazione, è necessario specificare una regione nel grafico. Quattro strumenti per questo vengono visualizzati nel menu a discesa sotto il selettore dell'asse Y. Seleziona istanza identifica un'istanza particolare. Il rettangolo (mostrato nella Figura 10.13 (a)) consente di trascinare un rettangolo sul grafico. Con Polygon e Polyline è possibile creare un poligono a forma libera oppure disegnare una polilinea a forma libera (fare clic con il pulsante sinistro per aggiungere un vertice e fare clic con il pulsante destro del mouse per completare l'operazione). Una volta selezionata un'area, diventa grigio. Nella Figura 10.13 (a) l'utente ha definito un rettangolo. Il pulsante Invio crea due nuovi nodi nell'albero, uno che tiene le istanze selezionate e l'altra con tutto il resto. Cancella Cancella la selezione; Salva salva le istanze nel nodo dell'albero corrente come un file ARFF. A questo punto, l'albero visualizzatore mostra l'albero in Figura 10.13 (b). C'è un nodo puro per la classe cielo, ma l'altro nodo è misto e deve essere suddiviso ulteriormente. Fare clic su diversi nodi determina quale sottoinsieme di dati viene visualizzato dal Visualizzatore dati. Continuare ad aggiungere i nodi finché non si è soddisfatti del risultato, cioè fino a quando i nodi fogliari sono per lo più pura. Quindi fare clic con il pulsante destro del mouse su uno spazio vuoto nel Visualizzatore albero e scegliere Accetta l'albero. Weka valuta il tuo albero sul set di test e fornisce le statistiche sulle prestazioni (l'80% è un buon risultato su questo problema).

   Costruire alberi manualmente è molto noioso. Ma Weka può completare l'attività per te creando un sottostrutto sotto qualsiasi nodo: basta fare clic con il pulsante destro del mouse sul nodo.
    Using a metalearner

  Figure 10.13 Working on the segmentation data with the User Classifier:

  Metalearners (Sezione 7.5) prendono classifici semplici e li trasformano in discenti più potenti. Ad esempio, per aumentare le decisioni di decisione nell'Explorer, vai al pannello Classify e scegli il classificatore AdaboostM1 dalla sezione meta del menu gerarchico. Quando si configura questo classificatore facendo clic su di esso, viene visualizzato l'editor di oggetti mostrato in Figura 10.14. Questo ha un proprio campo di classificatore, che abbiamo impostato su DecisionStump (come mostrato). Questo metodo potrebbe essere configurato facendo clic (ad eccezione di che DecisionStump accade di non avere proprietà modificabili). Fai clic su OK per tornare al pannello Classify principale e inizia a provare ad aumentare i ceppi di decisione fino a 10 volte. Si scopre che questo mislabele solo 7 delle 150 istanze nell'insieme dei dati Iris, con una buona performance considerando la natura rudimentale dei ceppi di decisione e il numero piuttosto ridotto di iterazioni.
   Clustering and association rules

  Utilizzare i pannelli Cluster e Associate per richiamare gli algoritmi di cluster (sezione 6.6) ei metodi per trovare le regole di associazione (Sezione 4.5). Quando raggruppa, Weka mostra il numero di cluster e quante istanze contiene ciascun cluster. Per alcuni algoritmi è possibile specificare il numero di cluster impostando un parametro nell'editor di oggetto. Per i metodi di clustering probabilistici, Weka misura la probabilità di log dei cluster sui dati di addestramento: maggiore è la quantità, più meglio il modello è adatto ai dati. L'aumento del numero di cluster aumenta normalmente la probabilità, ma può sovrascrivere.
  I comandi del pannello Cluster sono simili a quelli di Classify. È possibile specificare alcuni degli stessi metodi di valutazione - utilizzare il set di formazione, il set di test fornito e la percentuale di suddivisione (gli ultimi due vengono utilizzati con la probabilità di log). Un ulteriore metodo, classi per la valutazione dei cluster, confronta quanto i cluster scelti corrispondano a una classe preassegnata nei dati. Si seleziona un attributo (che deve essere nominale) che rappresenta la classe "vera". Dopo aver raggruppato i dati, Weka determina la classe di maggioranza in ciascun cluster e stampa una matrice di confusione mostrando quanti errori ci saranno se i cluster sono stati utilizzati anziché la classe vera. Se il tuo set di dati dispone di un attributo di classe, puoi ignorarlo durante il clustering selezionandolo da un elenco a discesa degli attributi e vedere come i cluster corrispondono ai valori di classe effettivi. Infine, puoi scegliere se memorizzare i cluster per la visualizzazione. L'unico motivo per non farlo è conservare lo spazio. Come con i classificatori, visualizzerai i risultati facendo clic con il pulsante destro del mouse sull'elenco dei risultati, che consente di visualizzare i diagrammi bidimensionali di dispersione come quello di Figura 10.6 (b). Se hai scelto classi per la valutazione dei cluster, vengono visualizzati gli errori di assegnazione della classe. Per lo schema di clustering di Cobweb, puoi ancheVisualizzare l'albero.

  Il pannello Associate è più semplice di Classify o Cluster. Weka contiene solo tre algoritmi per determinare le regole di associazione e nessun metodo per valutare tali regole. La Figura 10.15 mostra l'uscita del programma Apriori per le regole di associazione (descritte nella sezione 4.5) sulla versione nominale dei dati meteorologici. Nonostante la semplicità dei dati, si trovano diverse regole. Il numero prima della freccia è il numero di istanze per le quali l'antecedente è vero; Che dopo la freccia sia il numero di istanze in cui anche il conseguente è vero; E la fiducia (in parentesi) è il rapporto tra i due. Per impostazione predefinita si possono trovare dieci regole: è possibile chiedere di più utilizzando l'editor di oggetti per modificare numRules.
   Attribute selection

  Il pannello Select attributes consente di accedere a diversi metodi per la selezione degli attributi. Come spiegato nella sezione 7.1, ciò comporta un valutatore di attributo e un metodo di ricerca. Entrambe vengono scelte nel modo consueto e configurate con l'editor di oggetti. È inoltre necessario decidere quale attributo utilizzare come classe. La selezione degli attributi può essere eseguita utilizzando il set completo di formazione o utilizzando la convalida incrociata. In quest'ultimo caso viene fatto separatamente per ogni piega e l'output mostra quante volte - cioè in quante delle pieghe - ciascun attributo è stato selezionato. I risultati vengono memorizzati nell'elenco di cronologia. Quando si fa clic con il pulsante destro del mouse su una voce, è possibile visualizzare il set di dati in termini di attributi selezionati (scegliere Visualizzare dati ridotti).
     Visualization

  Il pannello Visualizza consente di visualizzare un set di dati, non il risultato di un modello di classificazione o di clustering, ma il set di dati stesso. Essa mostra una matrice di disegni bidimensionali di dispersione di ogni coppia di attributi. La Figura 10.16 (a) mostra il set di dati dell'iride. È possibile selezionare un attributo - normalmente la classe - per colorare i punti dati utilizzando i comandi in basso. Se è nominale, la colorazione è discreta; Se è numerico, lo spettro di colore varia continuamente dal blu (valori bassi) all'arancia (valori elevati). I punti dati senza valore di classe sono mostrati in nero. È possibile modificare le dimensioni di ciascuna trama, la dimensione dei punti e la quantità di jitter, che è uno spostamento casuale applicato ai valori X e Y per separare i punti che si trovano in cima all'altro. Senza jitter, 1000 istanze allo stesso punto dati sarebbero uguali a 1 istanza. È possibile ridurre la dimensione della matrice di appezzamenti selezionando determinati attributi e potete sottomettere i dati per l'efficienza. Le modifiche dei controlli non hanno effetto finché non viene fatto clic sul pulsante Aggiorna.

   Clicca su uno dei diagrammi della matrice per ingrandirlo. Ad esempio, cliccando sulla parte superiore della traccia sinistra viene visualizzato il pannello in Figura 10.16 (b). È possibile ingrandire l'area di questo pannello scegliendo Rettangolo dal menu in alto a destra e trascinando un rettangolo nell'area di visualizzazione visualizzata. Il pulsante Invia in alto a sinistra riduce il rettangolo nell'area di visualizzazione.
     Filtering algorithms

 Ora prendiamo uno sguardo dettagliato sugli algoritmi di filtraggio implementati all'interno di Weka. Questi sono accessibili dall'Explorer e anche dalle interfacce Knowledge Flow e Experimenter descritte nei capitoli 11 e 12. Tutti i filtri trasformano in modo inadatto il set di dati di input. Quando viene selezionato un filtro usando il pulsante Scegli, il suo nome viene visualizzato nella riga accanto a quel pulsante. Fare clic su quella riga per ottenere un generico oggetto editor per specificare le proprie proprietà. Quella che appare nella riga è la versione della riga di comando del filtro e i parametri sono specificati con segni meno. Questo è un buon modo per imparare a utilizzare direttamente i comandi di Weka.
   Ci sono due tipi di filtri: non sorvegliati e supervisionati (Sezione 7.2). Questa distinzione apparentemente innocua maschera una questione piuttosto fondamentale. I filtri vengono spesso applicati a un set di dati di formazione e poi applicati al file di prova. Se il filtro è sorvegliato, ad esempio, se utilizza valori di classe per ottenere buoni intervalli per la discretizzazione, applicandolo ai dati di prova bias i risultati. Sono gli intervalli di discretizzazione derivanti dai dati di addestramento che devono essere applicati ai dati di prova. Quando si utilizzano filtri sorvegliati, è necessario fare attenzione affinché i risultati siano valutati in modo equo, un problema che non si verifica con i filtri non supervisionati.
  Trattiamo separatamente i metodi di filtraggio senza supervisione e supervisione di Weka. All'interno di ciascun tipo c'è un'ulteriore distinzione tra i filtri degli attributi, che funzionano sugli attributi nei set di dati e nei filtri di istanza, che funzionano sulle istanze. Per ulteriori informazioni su un particolare filtro, selezionarla nell'Explorer di Weka e guardare il relativo editor di oggetto associato, che definisce ciò che il filtro fa e i parametri che richiede.

      Adding and removing attributes
  Aggiungi inserisce un attributo in una data posizione, il cui valore è dichiarato mancante per tutte le istanze. Utilizza l'editor generico dell'oggetto per specificare il nome dell'attributo, dove apparirà nell'elenco degli attributi e sui relativi valori (per gli attributi nominali). Copia gli attributi esistenti in modo da poterli preservare durante la sperimentazione di filtri che sovrascrivono i valori degli attributi. Diversi attributi possono essere copiati insieme utilizzando un'espressione come 1-3 per i primi tre attributi, o primo-3,5,9-ultimi per gli attributi 1, 2, 3, 5, 9, 10, 11, 12,. . . . La selezione può essere invertita, influenzando tutti gli attributi, tranne quelli specificati. Queste caratteristiche sono condivise da molti filtri.Rimozione è già stata descritta. Filtri simili sono RemoveType, che elimina tutti gli attributi di un dato tipo (nominale, numerico, stringa o data) e RemoveUseless, che elimina gli attributi costanti e gli attributi nominali i cui valori sono diversi per quasi tutte le istanze. Puoi decidere quanta "variazione" viene tollerata prima che un attributo venga eliminato specificando il numero di valori distinti come percentuale del numero totale di valori. Alcuni filtri di attributo non controllati si comportano diversamente se il menu del pannello Preprocess è stato utilizzato per impostare un attributo di classe. Ad esempio, RemoveType e RemoveUseless ignorano l'attributo di classe.

  AddCluster applica un algoritmo di cluster ai dati prima di filtrarlo. Utilizza l'editor di oggetti per scegliere l'algoritmo di clustering. I cluster sono configurati proprio come i filtri sono (sezione 10.6). L'editor dell'oggetto AddCluster contiene il proprio pulsante Scegli per il cluster e si configura il clusterer facendo clic sulla relativa riga e ottenendo un altro pannello di modifica dell'oggetto, che deve essere compilato prima di ritornare all'editor degli oggetti AddCluster. Questo è probabilmente più facile da capire quando lo fai in pratica di quando lo si legge in un libro! Ad ogni modo, dopo aver scelto un cluster, AddCluster lo usa per assegnare un numero di cluster ad ogni istanza come un nuovo attributo. L'editor degli oggetti consente inoltre di ignorare determinati attributi durante il clustering specificato come descritto in precedenza per Copia.
  ClusterMembership utilizza un cluster, nuovamente specificato nell'editor di oggetti del filtro, associando i valori di appartenenza. Viene creata una nuova versione di ogni istanza, i cui attributi sono questi valori. L'attributo di classe, se impostato, è rimasto inalterato. AddExpression crea un nuovo attributo applicando una funzione matematica agli attributi numerici. L'espressione può contenere riferimenti di attributo e costanti; Gli operatori aritmetici +, -, *, / e Ÿ; Le funzioni log e exp, abs e sqrt, pavimento, ceil e rint, 5 e sin, cos e tan; E parentesi. Gli attributi sono specificati dal prefisso a, ad esempio, a7 è il settimo attributo. È un'espressione di esempio


 a1^2 * a5/log(a7 * 4.0)
 

  Esiste un'opzione di debug che sostituisce il valore del nuovo attributo con un parsing postfix dell'espressione fornita. Mentre AddExpression applica funzioni matematiche, NumericTransform esegue una trasformazione arbitraria applicando una funzione Java specifica agli attributi numerici selezionati. La funzione può essere qualsiasi cosa che prenda un doppio come argomento e restituisce un altro doppio, ad esempio, sqrt () in java.lang.Math.
     Un parametro è il nome della classe Java che implementa la funzione (che deve essere un nome completo); Un altro è il nome stesso del metodo di trasformazione. Normalizza scala tutti i valori numerici nel set di dati che vanno tra 0 e 1. La standardizzazione li trasforma in modo da avere una media di zero e una varianza di unità. Entrambi saltare l'attributo di classe, se impostato.
       Changing values

  SwapValues ​​scambia le posizioni di due valori di un attributo nominale. L'ordine dei valori è interamente cosmetico - non influisce affatto sull'apprendimento - ma se la classe è selezionata, modificare l'ordine influisce sul layout della matrice di confusione.
   MergeTwoValues ​​unisce i valori di un attributo nominale in una singola categoria. Il nome del nuovo valore è una concatenazione dei due originali e ogni evento di uno dei valori originali viene sostituito da quello nuovo. L'indice del nuovo valore è il più piccolo degli indici originali. Ad esempio, se si fondono i primi due valori dell'attributo di Outlook nei dati meteo - in cui sono presenti cinque soleggiate, quattro coperte e cinque istanze piovose - il nuovo attributo di outlook avrà valori sunny_overcast e piovoso; Ci saranno nove istanze sunny_overcast e gli originali cinque pioggia.
Un modo per affrontare i valori mancanti è sostituirli globalmente prima di applicare uno schema di apprendimento. ReplaceMissingValues ​​sostituisce ogni valore mancante con la media per gli attributi numerici e la modalità per quelli nominali. Se viene impostata una classe, i valori mancanti di tale attributo non vengono sostituiti.
    Conversions

  Molti filtri convertono gli attributi da una maschera all'altra. Discretizzare gli usi di equal-width o equal-frequency binning (Sezione 7.2) per discretizzare una gamma di attributi numerici, specificati nel modo consueto. Per il metodo precedente il numero di scomparti può essere specificato o scelto automaticamente massimizzando la probabilità utilizzando la convalida incrociata "leave-one-out". PKIDiscretize discretizza gli attributi numerici usando la binning di frequenza pari a cui il numero di cestini è la radice quadrata del numero di valori (esclusi i valori mancanti). Entrambi questi filtri salta l'attributo di classe.
  MakeIndicator converte un attributo nominale in un attributo di indicatore binario e può essere utilizzato per trasformare un set di dati multiclass in più di due classi. Sostituisce un attributo binario per quello nominale scelto, il cui valore per ogni istanza è 1 se un particolare valore originale è presente e 0 altrimenti. Il nuovo attributo viene dichiarato come numerico per impostazione predefinita, ma può essere nominale se lo si desidera.
  Alcuni schemi di apprendimento, come le macchine vettoriali di supporto, gestiscono solo gli attributi binari. Il filtro NominalToBinary trasforma tutti gli attributi nominali multivalore in un set di dati in binari, sostituendo ciascun attributo con k valori per k attributi binari utilizzando una semplice codifica unica per valore. Gli attributi già binari vengono lasciati intatti. NumericToBinary converte tutti gli attributi numerici in quelli binari nominali (ad eccezione della classe, se impostata). Se il valore dell'attributo numerico è esattamente 0, il nuovo attributo sarà 0 e, se manca, il nuovo attributo mancherà; Altrimenti, il valore del nuovo attributo sarà 1. Questi filtri trascurano anche l'attributo di classe.
  FirstOrder prende una gamma di attributi numerici N e li sostituisce con gli attributi numerici N-1 i cui valori sono le differenze tra i valori degli attributi consecutivi dalle istanze originali. Ad esempio, se i valori degli attributi originali erano 3, 2 e 1, quelli nuovi saranno -1 e -1.
     String conversion

  Un attributo di stringa ha un numero non specificato di valori. StringToNominal lo converte in nominale con un numero impostato di valori. È necessario assicurarsi che tutti i valori di stringa che verranno visualizzati nei dati potenziali di prova siano rappresentati nel set di dati. StringToWordVector produce gli attributi che rappresentano la frequenza di ciascuna parola nella stringa. L'insieme di parole - ovvero il nuovo attributo impostato - è determinato dal set di dati. Per impostazione predefinita, ogni parola diventa un attributo il cui valore è 1 o 0, che riflette la presenza della parola nella stringa. I nuovi attributi possono essere nominati con un prefisso definito dall'utente per mantenere gli attributi derivanti da differenti attributi di stringa distinti.
    Ci sono molte opzioni che influiscono sulla 'tokenization'. Le parole possono essere formate da sequenze alfabetiche contigue o separate da un determinato set di caratteri delimitatore. Possono essere convertiti in minuscole prima di essere aggiunti al dizionario oppure possono essere ignorate tutte le parole su un elenco predefinito di parole chiave in inglese. Le parole che non sono tra le parole di alto k classificate per frequenza possono essere scartate (leggermente più di k parole saranno mantenute se ci sono legami alla posizione di kth). Se è stato assegnato un attributo di classe, verranno mantenute le prime parole k per ciascuna classe. Il valore di ogni attributo parola riflette la sua presenza o assenza nella stringa, ma questo può essere modificato. È possibile utilizzare un conteggio del numero di volte che la parola appare nella stringa. Le frequenze di parola possono essere normalizzate per dare il vettore di attributo di ciascun documento la stessa lunghezza euclidea, questa lunghezza non è scelto per essere 1, per evitare i piccoli numeri che potrebbero comportare, ma per essere la lunghezza media di tutti i documenti che appaiono come valori della Originale attributo di stringa. In alternativa, le frequenze fij per parola i nel documento j possono essere trasformate usando log (1 + fij) o la misura TF * IDF (Sezione 7.3).
    Time series

  Due filtri funzionano con i dati della serie temporale. TimeSeriesTranslate sostituisce i valori di un attributo (o attributi) nell'istanza corrente con il valore equivalente in un'altra istanza (precedente o futura). TimeSeriesDelta sostituisce i valori degli attributi nell'istanza corrente con la differenza tra il valore corrente e il valore in un'altra istanza. In entrambi i casi, i casi in cui il valore temporizzato è sconosciuto possono essere rimossi oi valori mancanti possono essere utilizzati.
   Randomizing

 Altri filtri degli attributi degradano i dati. AddNoise assume un attributo nominale e modifica una data percentuale dei suoi valori. I valori mancanti possono essere mantenuti o modificati insieme al resto. Obfuscate anonimizza i dati rinominando la relazione, i nomi degli attributi e valori nominali e attributi di stringa. RandomProjection proietta il set di dati su uno spazio secondario di dimensioni inferiori utilizzando una matrice casuale con colonne di lunghezza dell'unità (Sezione 7.3). L'attributo di classe non è incluso nella proiezione.
   Unsupervised instance filters

  I filtri di istanza di Weka, elencati nella Tabella 10.2, interessano tutte le istanze di un set di dati piuttosto che tutti i valori di un determinato attributo o attributi.
    Randomizing and subsampling

 È possibile eseguire la casualizzazione dell'ordine delle istanze nel set di dati. Normalizza tratta tutti gli attributi numerici (esclusa la classe) come vettore e la normalizza a una data lunghezza. È possibile specificare la lunghezza del vettore e la norma da utilizzare.
  Ci sono diversi modi per generare sottoinsiemi dei dati. Usa Resample per produrre un campione casuale campionando con sostituzione o RemoveFolds per dividerlo in un certo numero di pieghe di convalida incrociate e ridurlo ad una sola di esse.
   Se viene fornito un seme di numero casuale, il set di dati verrà mescolato prima di estrarre il sottoinsieme. RemovePercentage rimuove una determinata percentuale di istanze e RemoveRange elimina una certa gamma di numeri di istanze. Per rimuovere tutte le istanze che hanno determinati valori per attributi nominali o valori numerici sopra o sotto una determinata soglia, utilizzare RemoveWithValues. Per impostazione predefinita vengono eliminate tutte le istanze che presentano uno di un determinato insieme di valori di attributo nominale (se l'attributo specificato è nominale) o un valore numerico al di sotto di un determinato valore (se è numerico). Tuttavia, il criterio corrispondente può essere invertito. È possibile rimuovere gli outlier applicando un metodo di classificazione al set di dati (specificandolo come il metodo di clustering era stato specificato in precedenza per AddCluster) e utilizzare RemoveMisclassified per eliminare le istanze che ha errato classificato.
   Sparse instances

 I filtri NonSparseToSparse e SparseToNonSparse convertono tra la rappresentazione regolare di un set di dati e la sua rappresentazione sparsa (vedere la sezione 2.4).
    Supervised filters

  'I filtri sorvegliati' sono disponibili dal pannello Preprocesso di Explorer, così come quelli non sorvegliati. Bisogna stare attenti a loro perché, nonostante le apparenze, "non stanno realmente elaborando" le operazioni. Abbiamo notato questo in precedenza per quanto riguarda la discretizzazione: le divisioni dei dati di prova non devono utilizzare i valori di classe dei dati di prova, in quanto si suppone che siano sconosciuti, ed è vero per i filtri sorvegliati in generale.
   A causa della domanda popolare, Weka ti consente di invocare i filtri sorvegliati come un'operazione di precaricamento, proprio come i filtri non supervisionati. Tuttavia, se si intende usarli per la classificazione è necessario adottare una diversa metodologia. Viene fornito un meta-learner che invoca un filtro in un modo che avvolge l'algoritmo di apprendimento nel meccanismo di filtraggio. Questo filtra i dati di prova utilizzando il filtro creato dai dati di allenamento. È utile anche per alcuni filtri non controllati. Ad esempio, in StringToWordVector il dizionario verrà creato dai soli dati formativi: le parole che sono novel nei dati di prova verranno scartate.
  Per utilizzare in questo modo un filtro sorvegliato, richiamare lo schema metalearning FilteredClassifier dalla sezione meta del menu visualizzato dal pulsante Seleziona del gruppo Classify. La Figura 10.17 (a) mostra l'editor dell'oggetto per questo schema di metalearning. Con esso si sceglie un classificatore e un filtro. La Figura 10.17 (b) mostra il menu dei filtri.

  I filtri sorvegliati, come quelli non sorvegliati, sono suddivisi in filtri di attributo e di istanza elencati nella Tabella 10.3 e nella Tabella 10.4.
    Supervised attribute filters

  Discretizzare, evidenziato nella Figura 10.17, utilizza il metodo MDL di discretizzazione controllata (Sezione 7.2). È possibile specificare una serie di attributi o forzare l'attributo discretizzato come binario. La classe deve essere nominale. Per impostazione predefinita si utilizza il criterio di Fayyad e Irani (1993), ma il metodo di Kononenko (1995) è un'opzione.
   Esiste una versione sorvegliata del filtro NominalToBinary che trasforma tutti gli attributi nominali multivalore a quelli binari. In questa versione, la trasformazione dipende dal fatto che la classe sia nominale o numerica. Se è nominale, viene utilizzato lo stesso metodo come prima: un attributo con valori k viene trasformato in k binary attributes. Se la classe è numerica, tuttavia viene applicato il metodo descritto nella sezione 6.5 (pagina 246). In entrambi i casi la classe stessa non è trasformata.
  ClassOrder modifica l'ordinazione dei valori di classe. L'utente determina se il nuovo ordine è casuale o in ordine crescente o decrescente di frequenza di classe. Questo filtro non deve essere utilizzato con lo schema metalearning FilteredClassifier! AttributeSelection può essere utilizzato per la selezione automatica degli attributi e fornisce le stesse funzionalità del pannello di attributi Selezione Explorer (descritto più avanti).
    Supervised instance filters

  Ci sono tre filtri di istanza controllati. Il resample è come il filtro istanza non controllato di nome, tranne che mantiene la distribuzione di classe nel sottomenu. In alternativa, può essere configurato per bias la distribuzione della classe verso una forma uniforme. SpreadSubsample produce anche un sottotabo casuale, ma può essere controllata la differenza di frequenza tra la classe più rara e quella più comune. Ad esempio, è possibile specificare al massimo una differenza di 2: 1 nelle frequenze di classe. Come il filtro di istanza non protetto RemoveFolds, StratifiedRemoveFolds emette una piegatura di conferma specificata per il set di dati, a meno che questa volta la piega sia stratificata.
    Learning algorithms

  Nel pannello Classify, quando si seleziona un algoritmo di apprendimento usando il pulsante Scegli, nella riga accanto al pulsante viene visualizzata la versione della riga di comando del classificatore, inclusi i parametri specificati con segni meno. Per modificarli, fare clic su quella riga per ottenere un appropriato editor di oggetti. La tabella 10.5 elenca i classificatori di Weka. Sono divise in classificatori bayesiani, alberi, regole, funzioni, classificatori pigri e una categoria finale diversa. Li descriviamo brevemente qui insieme ai loro parametri. Per saperne di più, scegliete uno nell'interfaccia Weka Explorer e esamini il suo editor di oggetti. Un ulteriore tipo di classificatore, il Metalearner, è descritto nella sezione successiva.
   Bayesian classifiers

  NaiveBayes implementa il probabilistico classificatore Naïve Bayes (Sezione 4.2). NaiveBayesSimple utilizza la distribuzione normale per modellare gli attributi numerici. NaiveBayes può utilizzare stimatori di densità del kernel, che migliora le prestazioni se l'assunto di normalità è grossolanamente errato; Può anche gestire gli attributi numerici utilizzando la discretizzazione supervisionata. NaiveBayesUpdateable è una versione incrementale che elabora un'istanza alla volta; Può utilizzare un stimatore del kernel, ma non la discretizzazione. NaiveBayesMultinomial implementa il classificatore multinomiale Bayes (Sezione 4.2, pagina 95). ComplementNaiveBayes costruisce un classificatore Bayes Complemento Naïve come descritto da Rennie et al. (2003) (le trasformazioni TF * IDF e normalizzazione di lunghezza utilizzate in questo documento possono essere eseguite usando il filtro StringToWordVector).L'AODE (medie, stime di dipendenza da una dipendenza) è un metodo Bayesiano che media in uno spazio di modelli Bayesiani alternativi che hanno ipotesi di indipendenza più debole di Naïve Bayes (Webb et al., 2005). L'algoritmo può produrre una classificazione più precisa di Naïve Bayes su set di dati con attributi non indifferenziati.

   BayesNet apprende le reti bayesiane sotto le ipotesi di cui alla sezione 6.7: attributi nominali (numeri predefiniti) e nessun valore mancante (tali valori vengono sostituiti globalmente). Esistono due diversi algoritmi per la stima delle tabelle di probabilità condizionale della rete. La ricerca avviene usando K2 o l'algoritmo TAN (Sezione 6.7) o metodi più sofisticati basati su arrampicata su collina, ricottura simulata, ricerca tabù e algoritmi genetici. Facoltativamente, la velocità di ricerca può essere migliorata utilizzando gli alberi AD (sezione 6.7).
  C'è anche un algoritmo che utilizza test condivisi di indipendenza per imparare la struttura della rete; In alternativa, la struttura di rete può essere caricata da un file XML (estensione del linguaggio di marcatura). Ulteriori dettagli sull'implementazione delle reti bayesiane in Weka si trovano in Bouckaert (2004). È possibile osservare la struttura della rete facendo clic con il pulsante destro del mouse sull'elemento di cronologia e selezionando Visualize graph. La Figura 10.18 (a) mostra il grafico per la versione nominale dei dati meteorologici, che in realtà corrisponde al risultato Naïve Bayes con tutte le probabilità condizionate dal valore della classe. Ciò è dovuto al fatto che l'algoritmo di ricerca predefinito è K2 con il numero massimo di genitori di un nodo impostato su uno. La riconfigurazione di questo a tre facendo clic su K2 nel pannello di configurazione rende la rete più interessante nella Figura 10.18 (b). Fare clic su un nodo mostra la sua distribuzione di probabilità - la Figura 10.18 (c) si ottiene cliccando sul nodo ventoso di Figura 10.18 (b).

   

   Figure 10.18 Visualizing a Bayesian network
    Trees

Dei classificatori dell'albero nella tabella 10.5 abbiamo già visto come usare J4.8, che reimplements C4.5 (Sezione 6.1). Per visualizzare le opzioni, fai clic sulla riga accanto al pulsante Scegli in Figura 10.4 (b) per aprire l'editor di oggetti in Figura 10.19. È possibile costruire un albero binario anziché uno con rami multipli. È possibile impostare la soglia di sicurezza per la potatura (impostazione predefinita 0.25) e il numero minimo di istanze consentite in una foglia (impostazione predefinita 2). Invece di potatura standard C4.5 è possibile scegliere la potatura a errori ridotti (sezione 6.2). Il parametro numFolds (default 3) determina la dimensione del set di potatura: i dati sono suddivisi in modo uguale in quel numero di parti e l'ultimo utilizzato per la potatura. Quando si visualizza l'albero (pagine 377-378) è bello poter consultare i punti dati originali, che è possibile eseguire se 'saveInstanceData' è stato attivato (è disattivato o Falso per impostazione predefinita per ridurre i requisiti di memoria) . È possibile sopprimere il subtree, sollevando un algoritmo più efficiente; Forzare l'algoritmo per usare l'albero non trattato invece del potato; O utilizzare la levigatura Laplace per le probabilità previste (Sezione 4.2).

   La tabella 10.5 mostra molti altri metodi decisionali. Id3 è l'algoritmo di base descritto nel Capitolo 4. DecisionStump, progettato per l'utilizzo con i metodi di incremento descritti più avanti, crea alberi decisionali binari di un livello per i set di dati con una classe categorica o numerica, trattandosi di valori mancanti trattandoli come valore separato e Estendendo un terzo ramo dal ceppo. Gli alberi costruiti da RandomTree scelgono un test basato su un dato numero di funzioni casuali in ogni nodo, senza eseguire potature. RandomForest costruisce foreste casuali mediante l'insaccamento di ensemble di alberi casuali (Sezione 7.5, pagine 320-321). REPTree crea un albero di decisione o di regressione utilizzando la riduzione di guadagno / varianza delle informazioni e lo prugge utilizzando una potatura a errore ridotto (sezione 6.2, pagina 203). Ottimizzato per la velocità, solo una volta classifica valori per gli attributi numerici (sezione 6.1, pagina 190). Si tratta dei valori mancanti dividendo le istanze in pezzi, come fa C4.5. È possibile impostare il numero minimo di istanze per foglia, la profondità massima dell'albero (utile per aumentare gli alberi), la percentuale minima della variazione di formazione impostata per una suddivisione (solo classi numeriche) e il numero di pieghe per la potatura.
   NBTree è un ibrido tra gli alberi decisionali e Naïve Bayes. Crea alberi i cui fogli sono classificatori Naïve Bayes per i casi che raggiungono la foglia. Quando si costruisce l'albero, la convalida incrociata viene utilizzata per decidere se un nodo deve essere suddiviso ulteriormente o utilizzare invece un modello Naïve Bayes (Kohavi 1996).

  M5P è il "modello di apprendimento degli alberi" descritto nella sezione 6.5. LMT costruisce alberi modello logistico (Sezione 7.5, pagina 331). LMT può occuparsi delle variabili di destinazione binarie e multiclassiche, degli attributi numerici e nominali e dei valori mancanti. Quando si adatta alle funzioni di regressione logistica in un nodo, utilizza la convalida incrociata per determinare quante iterazioni eseguire una sola volta e impiega lo stesso numero in tutta l'albero anziché la convalida incrociata in ogni nodo. Questo euristico (che si può spegnere) migliora notevolmente il tempo di esecuzione, con scarso effetto sulla precisione. In alternativa, è possibile impostare il numero di incrementi di iterazioni da utilizzare per tutta l'albero. Normalmente, è l'errore di errori di errori che la convalida incrociata minimizza, ma l'errore medio-quadrato di root delle probabilità può essere scelto invece. Il criterio di suddivisione può essere basato sul guadagno informativo C4.5 (il valore predefinito) o sui residui di LogitBoost, cercando di migliorare la purezza dei residui.
  ADTree costruisce un albero di decisione alternato utilizzando il boosting (Sezione 7.5, pagine 329-331) ed è ottimizzato per problemi a due livelli. Il numero di incrementi di iterazioni è un parametro che può essere sintonizzato in base al set di dati e al compromesso di precisione di complessità desiderata. Ogni iterazione aggiunge tre nodi all'albero (un nodo di split e due nodi di previsione) a meno che i nodi non possano essere fusi. Il metodo di ricerca predefinito è una ricerca esaustiva (Espandi tutti i percorsi); Le altre sono euristiche e sono molto più veloci. È possibile determinare se salvare i dati di istanza per la visualizzazione.
     Rules

   La tabella 10.5 mostra molti metodi per la generazione di regole. DecisionTable crea un classificatore di maggioranza della tabella delle decisioni (Sezione 7.1, pagina 295). Valuta i sottoscrittori delle funzioni utilizzando la prima ricerca migliore e può utilizzare la convalida incrociata per la valutazione (Kohavi 1995b). Un'opzione utilizza il metodo più vicino per determinare la classe per ogni istanza che non è coperta da una voce di tabella di decisione, anziché la maggioranza globale della tabella, sulla base dello stesso set di funzionalità. OneR è il classificatore 1R (Sezione 4.1) con un parametro: la dimensione minima del secchio per la discretizzazione. ConjunctiveRule impara una singola regola che prevede un valore numerico o un valore nominale. Le istanze di prova non coperte vengono assegnate al valore di classe predefinito (o distribuzione) delle istanze di formazione non scoperte. Viene calcolato il guadagno di informazioni (classe nominale) o la riduzione della varianza (classe numerica) di ciascun antecedente e le regole sono potate utilizzando la potatura a errori ridotti. ZeroR è ancora più semplice: prevede la classe di maggioranza dei dati del test (se nominale) o il valore medio (se numerico).
   Prism implementa l'algoritmo di copertura elementare per le regole (Sezione 4.4). La parte ottiene le regole dagli alberi decisionali parziali (Sezione 6.2, pagine 207-210). Costruisce l'albero utilizzando l'euristica C4.5 con gli stessi parametri definiti dall'utente come J4.8. M5Rules ottiene regole di regressione da alberi modello costruiti utilizzando M5 ¢ (Sezione 6.5, pagine 250-251). Ridor impara le regole con eccezioni (sezione 6.2, pagine 210-213) generando la regola predefinita, utilizzando la potatura incrementale di errori ridotti per trovare eccezioni con il minor tasso di errore, trovare le eccezioni migliori per ogni eccezione e l'iterazione.
  JRip implementa RIPPER (Sezione 6.2, pagine 205-207), inclusa l'ottimizzazione globale heuristica del set di regole (Cohen 1995). Nnge è un metodo di prossimità più vicino per generare regole usando esemplari generalizzati non attivati ​​(Sezione 6.4, pagine 238-239).
     Funzioni

  La categoria di funzioni della Tabella 10.5 include un gruppo assortito di classificatori che possono essere scritti come equazioni matematiche in modo ragionevolmente naturale. Altri metodi, come gli alberi decisionali e le regole, non possono (ci sono eccezioni: Naïve Bayes ha una semplice formulazione matematica). Tre di essi attuano la regressione lineare (sezione 4.6). SimpleLinearRegression impara un modello di regressione lineare basato su un singolo attributo: sceglie quello che produce l'errore quadrato più piccolo. Non sono ammessi valori mancanti e attributi non numerici. LinearRegression esegue la regressione lineare standard a minimi quadrati e può facoltativamente eseguire la selezione degli attributi, utilizzando avidamente l'eliminazione indietro (Sezione 7.1) o costruendo un modello completo di tutti gli attributi e abbassando i termini uno per uno in ordine decrescente dei loro coefficienti standardizzati fino ad una arresto È stato raggiunto un criterio (questo metodo è stato descritto in un contesto leggermente diverso nella sezione 6.5 sotto Potatura dell'albero, pagina 245). Entrambi i metodi utilizzano una versione del criterio di terminazione AIC del capitolo 6.7 (pagina 277). L'implementazione ha due ulteriori perfezionamenti: un meccanismo per rilevare gli attributi collineari (che possono essere spenti) e un parametro di cresta che stabilizza i casi degenerati e può ridurre l'overfitting penalizzando i grandi coefficienti.
    Tecnicamente, LinearRegression implementa la regressione delle creste, descritta in testi statistici standard. LeastMedSq è un robusto metodo di regressione lineare che riduce al minimo la mediana (piuttosto che la media) dei quadrati delle divergenze dalla linea di regressione (Sezione 7.4) (Rousseeuw e Leroy 1987). Essa applica ripetutamente la regressione lineare standard ai sottotitoli dei dati e emette la soluzione che ha il più piccolo errore mediano-quadrato.

  SMO implementa l'algoritmo minimo di ottimizzazione sequenziale per la formazione di un classificatore di supporto vettoriale (Sezione 6.3), utilizzando i kernel polinomiali o Gaussiani (Platt 1998, Keerthi et al., 2001). I valori mancanti vengono sostituiti globalmente, gli attributi nominali vengono trasformati in binari e gli attributi vengono normalizzati per impostazione predefinita. Nota che i coefficienti nell'output sono basati sui dati normalizzati. La normalizzazione può essere disattivata, oppure l'ingresso può essere standardizzato a zero di media e di varianza dell'unità. La classificazione Pairwise è utilizzata per problemi multiclasse. I modelli di regressione logistica possono essere montati sull'uscita della macchina vettoriale di supporto per ottenere stime di probabilità. Nel caso multiclasse le probabilità previste saranno accoppiate in coppia (Hastie e Tibshirani 1998).
   Quando si lavora con istanze sparse, disattivare la normalizzazione per un funzionamento più veloce. SMOreg implementa l'algoritmo minimo di ottimizzazione sequenziale per i problemi di regressione (Smola e Schölkopf 1998). VotedPerceptron è l'algoritmo perceptronato votato (Sezione 6.3, pagine 222-223). Winnow (sezione 4.6, pagine 126-128) modifica il perceptron di base per utilizzare aggiornamenti moltiplicativi. L'implementazione consente di utilizzare un secondo moltiplicatore, b - diverso da 1 / a - al posto delle divisioni di Figura 4.11 e fornisce anche la versione equilibrata dell'algoritmo.PaceRegression costruisce modelli di regressione lineare utilizzando la nuova tecnica della regressione Pace (Wang e Witten 2002). Quando ci sono molti attributi, la regressione di Pace è particolarmente buona per determinare quali scartare, anzi, in determinate condizioni di regolarità è probabilmente ottimale in quanto il numero di attributi tende all'infinito.

  SimpleLogistic costruisce modelli di regressione logistica (Sezione 4.6, pagine 121-124), adattandoli usando LogitBoost con funzioni di regressione semplici come discenti base e determinando quante iterazioni da eseguire utilizzando cross-validation - che supporta la selezione automatica degli attributi (Landwehr et al 2003) . Logistic è un'implementazione alternativa per la costruzione e l'utilizzo di un modello di regressione logistica multinomiale con un estimatore di cresta per contrastare l'overfitting penalizzando grandi coefficienti, basati sul lavoro di Le Cessie e van Houwelingen (1992).
  RBFNetwork implementa una rete di funzioni radiali basata su Gaussian (sezione 6.3, pagina 234), derivando i centri e le larghezze di unità nascoste usando k-means e combinando le uscite ottenute dallo strato nascosto usando la regressione logistica se la classe è regressione nominale e lineare se È numerico. Le attivazioni delle funzioni di base vengono normalizzate per somma a una prima di essere alimentate nei modelli lineari. È possibile specificare k, il numero di cluster; Il numero massimo di iterazioni di regressione logistica per problemi di classe nominale; La deviazione standard minima per i cluster; E il valore della cresta per la regressione. Se la classe è nominale, k-means viene applicato separatamente per ogni classe per derivare k cluster per ogni classe.
      Neural networks

  MultilayerPerceptron è una rete neurale che tira utilizzando backpropagation (Sezione 6.3, pagina 227). Sebbene elencato nelle funzioni nella Tabella 10.5, esso differisce dagli altri schemi perché ha una propria interfaccia utente. Se si carica la versione numerica dei dati meteorologici, invoca MultilayerPerceptron, imposta GUI a True nel suo editor di oggetto e esegue la rete cliccando su Start sul pannello Classify, lo schema di Figura 10.20 viene visualizzato in una finestra separata. Questa rete ha tre livelli: uno strato di input a sinistra con una casella rettangolare per ogni attributo (verde colorato); Un livello nascosto accanto a esso (rosso) a cui sono collegati tutti i nodi d'ingresso; E un livello di uscita a destra (arancio). Le etichette in alto a destra mostrano le classi che rappresentano i nodi di output. I nodi di uscita per le classi numeriche vengono automaticamente convertiti in unità lineari non soggette a soglia.
   Prima di fare clic su Avvia per eseguire la rete, è possibile modificarne la struttura aggiungendo nodi e connessioni. È possibile selezionare o deselezionare i nodi. Tutti e sei i nodi nei livelli nascosti e di uscita della Figura 10.20 (a) sono deselezionati, indicati dal colore grigio del loro centro. Per selezionare un nodo, basta cliccare su di esso. Questo modifica il colore del suo centro da grigio a giallo brillante. Per deselezionare un nodo, fare clic con il pulsante destro del mouse in uno spazio vuoto. Per aggiungere un nodo, assicurati che nessuno sia selezionato e clicchi con il tasto sinistro in qualsiasi punto del pannello; Il nuovo nodo verrà selezionato automaticamente. Nella Figura 10.20 (a), un nuovo nodo è stato aggiunto al centro inferiore. Per collegare due nodi, selezionare il nodo iniziale e quindi fare clic su quello finale. Se vengono selezionati più nodi di avvio, tutti sono collegati al nodo finale. Se si sceglie invece nello spazio vuoto, viene creato un nuovo nodo come nodo finale. Si noti che le connessioni sono direzionali (anche se le indicazioni non sono mostrate). I nodi di avvio rimangono selezionati; Quindi è possibile aggiungere un intero strato nascosto con pochi clic, come mostrato nella Figura 10.20 (b). Per rimuovere un nodo, assicurarsi che non siano selezionati nodi e fare clic con il pulsante destro del mouse; Questo rimuove anche tutte le connessioni ad esso. Per rimuovere una singola connessione, selezionare un nodo e fare clic con il pulsante destro del mouse sul nodo all'altro capo.

   Oltre a configurare la struttura della rete, è possibile controllare il tasso di apprendimento, il suo slancio (sezione 6.3) e il numero di passaggi che passerà attraverso i dati, chiamati epoche. La rete inizia a formarsi quando si fa clic su Avvio e viene mostrata un'indicazione di funzionamento dell'epoca e l'errore per quella epoca nella parte inferiore sinistra del pannello di Figura 10.20. Si noti che l'errore si basa su una rete che cambia quando il valore viene calcolato. Per le classi numeriche il valore di errore dipende dalla normalizzazione della classe. La rete si ferma quando viene raggiunto il numero specificato di epoche, in questo momento è possibile accettare il risultato o aumentare il numero desiderato di epoche e premere nuovamente Start per continuare la formazione.
   MultilayerPerceptron non deve essere eseguito attraverso l'interfaccia grafica. È possibile impostare diversi parametri dall'editor dell'oggetto per controllarne il funzionamento. Se si utilizza l'interfaccia grafica, essi governano la struttura di rete iniziale, che è possibile sovrascrivere in modo interattivo. Con l'impostazione di autoBuild, i livelli nascosti vengono aggiunti e collegati. L'impostazione predefinita è quella di avere il solo livello nascosto mostrato nella Figura 10.20 (a), ma senza AutoBuild questo non apparirebbe e non ci sarebbero connessioni. Il parametro hiddenLayers definisce i livelli nascosti presenti e quanti nodi ciascuno contiene. La Figura 10.20 (a) viene generata da un valore di 4 (uno strato nascosto con quattro nodi) e anche se la Figura 10.20 (b) è stata creata aggiungendo i nodi in modo interattivo, potrebbe essere stato generato impostando Layers nascosti su 4,5 Strato nascosto con quattro nodi e un altro con cinque). Il valore è un elenco separato da virgole di interi; 0 non fornisce strati nascosti. Inoltre, esistono valori predefiniti che possono essere utilizzati anziché numeri interi: i è il numero di attributi, o il numero di valori di classe, la media dei due e la loro somma. L'impostazione predefinita, a, è stata utilizzata per generare la Figura 10.20 (a).

  I parametri learningRate e Momentum impostano valori per queste variabili, che possono essere sovrascritti nell'interfaccia grafica. Un parametro di decadimento determina una diminuzione del tempo di apprendimento nel tempo: divide il valore iniziale per il numero di epoca per ottenere il tasso corrente. Ciò a volte migliora le prestazioni e può impedire la divergenza della rete. Il parametro di reset ripristina automaticamente la rete con un tasso di apprendimento inferiore e riprende l'addestramento se è diverso dalla risposta (questa opzione è disponibile solo se l'interfaccia utente grafica non viene utilizzata).
  Il parametro trainingTime imposta il numero di epoche di formazione. In alternativa, una percentuale dei dati può essere impostata per la convalida (con validazione-SetSize): la formazione continua fino a quando la prestazione sul set di convalida inizia a deteriorarsi in modo coerente o fino a quando non viene raggiunto il numero specificato di epoche. Se la percentuale è impostata su zero, non viene utilizzato alcun set di convalida. Il parametro validationThresh-old determina quante volte consecutive l'errore di configurazione della convalida può peggiorare prima che la formazione sia arrestata.
   Il filtro nominaleToBinaryFilter viene specificato per impostazione predefinita nell'editor di oggetti MultilayerPerceptron; Spegnimento può migliorare le prestazioni sui dati in cui gli attributi nominali sono veramente ordinali. Gli attributi possono essere normalizzati (con normalizeAttributes) e una classe numerica può anche essere normalizzata (con normalizeNumericClass): entrambi possono migliorare le prestazioni.
       Lazy classifiers

  "Lazy learners" memorizzano le istanze di formazione e non fanno alcun lavoro reale fino al momento della classificazione. IB1 è un principiante basata sull'istanza (sezione 4.7) che trova l'istanza di addestramento più vicina alla distanza Euclidea rispetto alla data istanza di prova e predice la stessa classe di questa istruzione. Se più istanze si qualificano come il più vicino, viene utilizzato il primo trovato. IBk è un classificatore K-prossimo vicino che usa la stessa metrica a distanza. Il numero di vicini più vicini (default k = 1) può essere specificato esplicitamente nell'editor di oggetto o determinato automaticamente usando la "convalida incrociata" di una "uscita", soggetta ad un limite superiore specificato dal valore specificato. Le previsioni di più di un vicino possono essere ponderate in base alla loro distanza dall'istanza di prova e sono state implementate due formule diverse per convertire la distanza in un peso. Il numero di istanze di formazione mantenute dal classificatore può essere limitato impostando l'opzione di dimensione della finestra. Poiché vengono aggiunte istanze di formazione nuove, vengono rimosse quelle più vecchie per mantenere il numero di istanze di formazione a questa dimensione. KStar è un metodo di prossimità più vicino con una funzione di distanza generalizzata basata sulle trasformazioni (Sezione 6.4 pagine 241-242).

   LBR (per le Regole Lazy Bayesian) è un classificatore Bayesiano che limita l'elaborazione fino alla data di classificazione. Per ogni istanza di prova seleziona una serie di attributi per i quali l'assunzione di indipendenza non deve essere fatta; Gli altri vengono trattati come indipendenti l'uno dall'altro data la classe e l'insieme selezionato di attributi. Funziona bene per piccoli gruppi di test (Zheng e Webb 2000).
    LWL è un algoritmo generale per l'apprendimento localmente ponderato. Assegna pesi utilizzando un metodo basato su istanza e costruisce un classificatore dalle istanze ponderate. Il classificatore è selezionato nell'editor dell'oggetto LWL: una buona scelta è Naïve Bayes per i problemi di classificazione e la regressione lineare per i problemi di regressione (Sezione 6.5, pagine 251-253). È possibile impostare il numero di vicini usati, che determina la larghezza di banda del kernel e la forma del kernel da utilizzare per la ponderazione-lineare, inversa o Gaussiana. La normalizzazione degli attributi è attivata per impostazione predefinita.
        Miscellaneous classifiers

  Il misc. La categoria comprende due semplici classificatori che sono stati menzionati alla fine della sezione 4.7 (pagina 136). Iperpipe, per problemi di classificazione discreti, registra l'intervallo di valori osservati nei dati di addestramento per ogni attributo e categoria e spiega quali intervalli contengono i valori attributi di un'istanza di prova, scegliendo la categoria con il maggior numero di intervalli corretti. VFI (intervalli di funzioni di voto) costruisce intervalli attorno a ciascuna classe distruttando gli attributi numerici e utilizzando intervalli di punti per quelli nominali, registra i conteggi di classe per ogni intervallo su ciascun attributo e classifica le istanze di prova votando (Demiroz e Guvenir 1997). Un semplice schema di ponderazione degli attributi assegna un peso maggiore a intervalli più sicuri, dove la fiducia è una funzione dell'entropia. VFI è più veloce di Naïve Bayes ma più lento di iperpipes. Né il metodo può gestire i valori mancanti.
   Metalearning algorithms

  Gli algoritmi di metalearning, elencati nella tabella 10.6, prendono classificatori e li trasformano in discenti più potenti. Un parametro specifica il classificatore di base; Altri specificheranno il numero di iterazioni per i sistemi come "baging" e "boosting" e un seme iniziale per il generatore di numeri casuali. Abbiamo già incontrato FilteredClassifier nella sezione 10.3: esegue un classificatore sui dati che è stato passato attraverso un filtro, che è un parametro. I parametri del filtro sono basati esclusivamente sui dati di addestramento, che è il modo appropriato per applicare un filtro sorvegliato per testare i dati.
     Bagging and randomization

  'Sacchetti baging' un classificatore per ridurre la varianza (Sezione 7.5, pagina 316). Questa implementazione funziona sia per la classificazione che per la regressione, a seconda dello studente di base. Nel caso della classificazione, le previsioni sono generate dalla media delle stime di probabilità, non di voto. Un parametro è la dimensione delle borse come percentuale del set di allenamento. Un altro è se calcolare l'errore di fuori-bag, che dà l'errore medio dei membri dell'assemblea (Breiman 2001).
  RandomCommittee è ancora più semplice: costruisce un insieme di classificatori di base e media le loro previsioni. Ciascuno è basato sugli stessi dati ma utilizza un seme di numero casuale differente (Sezione 7.5, pagina 320). Questo ha senso solo se il classificatore di base è randomizzato; Altrimenti, tutti i classificatori sarebbero uguali.
    Boosting

   AdaBoostM1 implementa l'algoritmo descritto nella Sezione 7.5 (pag. 321; Figura 7.7). Può essere accelerato specificando una soglia per la potatura del peso. I campioni AdaBoostM1 se il classificatore di base non è in grado di gestire istanze ponderate (è anche possibile forzare nuovamente il riesaminamento). MultiBoostAB combina il potenziamento(Boosting) con una variante di "bagging" per evitare overfitting (Webb 2000).
    Mentre l'aumento si applica solo alle classi nominali, l'AdditiveRegression migliora le prestazioni di un principio di regressione (Sezione 7.5, pagina 325). Esistono due parametri: il ritiro, che regola il tasso di apprendimento e il numero massimo di modelli da generare. Se quest'ultimo è infinito, il lavoro continua finché l'errore non smette di diminuire.

  Decorate costruisce gruppi di classificatori diversi utilizzando esempi di addestramento artificiali appositamente costruiti. Questa tecnica è sostenuta per migliorare in modo consistente sul classificatore di base e sul 'bagging' e sulla "foresta casuale" di meta-learners (Melville e Mooney, 2005) .6 Essa supera l'incremento su piccoli gruppi di addestramento e le rivale su più grandi. Un parametro è il numero di esempi artificiali da utilizzare come percentuale dei dati formativi. Un altro è il numero desiderato di classificatori nell'assemble, anche se l'esecuzione può terminare prematuramente perché il numero di iterazioni può anche essere limitato. I grandi gruppi generano di solito modelli più accurati, ma hanno più tempo di formazione e complessità del modello.
   LogitBoost esegue la regressione logistica addizionale (Sezione 7.5, pagina 327). Come AdaBoostM1, può essere accelerata specificando una soglia per la potatura del peso. Il numero appropriato di iterazioni può essere determinato utilizzando una convalida interna; Vi è un parametro di restringimento che può essere sintonizzato per prevenire l'overfitting; E puoi scegliere di riesaminare invece di ponderare nuovamente. RacedIncre-mentalLogitBoost apprende dalla competizione dei comitati LogitBoosted e opera in modo incrementale elaborando i dati in batch (pagine 347-348), rendendolo utile per grandi set di dati (Frank et al., 2002). Ogni membro del comitato viene appreso da un lotto diverso. La dimensione del lotto inizia a un minimo minimo e ripete ripetutamente fino a raggiungere un massimo preimpostato. Il riesaminamento viene utilizzato se il classificatore di base non è in grado di gestire istanze ponderate (è anche possibile forzare nuovamente il riesaminamento). La potatura di probabilità di log può essere utilizzata all'interno di ogni comitato: questo scarta i nuovi membri della commissione se riduce la probabilità di log in base ai dati di convalida. È possibile determinare quante istanze da tenere per la convalida. I dati di convalida vengono utilizzati anche per determinare quale comitato deve mantenere quando la formazione termina.
       Combining classifiers

  Vota fornisce un metodo di base per combinare i classificatori mediante la mediazione delle loro stime di probabilità (classificazione) o delle previsioni numeriche (regressione). MultiScheme seleziona il miglior classificatore da un insieme di candidati utilizzando la convalida incrociata della percentuale di accuratezza (classificazione) o di errore medio-quadrato (regressione). Il numero di pieghe è un parametro. È possibile utilizzare prestazioni sui dati formativi.
   Lo stacking combina i classificatori con l'impilamento (Sezione 7.5, pagina 332) per problemi di classificazione e di regressione. Specificare i classificatori di base, il meta-learner e il numero di pieghe di conflitto incrociate. StackingC implementa una variante più efficiente per il quale il metalearner deve essere uno schema numerico di previsione (Seewald 2002). Nella classificazione gli ingressi al metalearner sono le previsioni a livello di base che sono state contrassegnate (ad es., "Classificate") come corrette o non corrette. Per ogni classificatore di base viene appreso un metalearner che prevede quando il classificatore di base erronea. Proprio come l'impilatura può essere considerata come una generalizzazione del voto, la classificazione generalizza la selezione mediante la convalida incrociata (Seewald e Fürnkranz 2001).
       Cost-sensitive learning

  Ci sono due meta-learners per l'apprendimento sensibile ai costi (Sezione 5.7). La matrice di costo può essere fornita come parametro o caricata da un file nella directory impostata dalla proprietà onDemandDirectory, denominata dal nome di relazione e con il costo di estensione. CostSensitiveClassifier ridimensiona le istanze di formazione in base al costo complessivo assegnato a ciascuna classe (apprendimento sensibile ai costi, pagina 165) o prevede la classe con il costo meno criticato di classificazione piuttosto che quello più probabile (classificazione sensibile ai costi, pagina 164). MetaCost genera un unico classificatore sensibile al costo dal principiante di base (Sezione 7.5, pagine 319-320). Questa implementazione utilizza tutte le iterazioni di bagging durante la riclassificazione dei dati formativi (Domingos 1999 segnala un miglioramento marginale quando si utilizza solo quelle iterazioni che contengono ogni istanza di formazione per riclassificare). È possibile specificare la dimensione di ciascuna borsa e il numero di iterazioni di bagging.
    Optimizing performance

  Tre meta-learners utilizzano la tecnica del wrapper per ottimizzare le prestazioni del classificatore di base. AttributeSelectedClassifier seleziona gli attributi, riducendo la dimensionalità dei dati prima di passarla al classificatore (Sezione 7.1, pag. 290). È possibile scegliere il valutatore di attributo e il metodo di ricerca utilizzando il pannello Select attributes descritto nella sezione 10.2. CVParameterSelection ottimizza le prestazioni utilizzando la convalida incrociata per selezionare i parametri. Per ogni parametro viene fornita una stringa contenente i limiti inferiori e superiori e il numero di incrementi desiderato. Ad esempio, per variare il parametro -P da 1 a 10 in incrementi di 1, utilizzare P 1 10 11. È possibile specificare il numero di piegature di convalida incrociate.

  Il terzo meta-learner, ThresholdSelector, ottimizza la misura F (Sezione 5.7) selezionando una soglia di probabilità sull'uscita del classificatore. La prestazione può essere misurata sui dati di addestramento, su un set di tenuta o con la convalida incrociata. Le probabilità restituite dal discente di base possono essere riconfigurate nell'intera gamma [0,1], utile se le probabilità del sistema sono limitate a un sottogruppo ridotto. Il metalearner può essere applicato ai problemi multiclasse specificando il valore di classe per cui viene eseguita l'ottimizzazione


1. Il primo valore di classe
2. Il valore di seconda classe
3. Qualunque valore sia meno frequente
4. Qualunque sia il valore più frequente
5. La prima classe chiamata yes, pos (itive) o 1.
      Retargeting classifiers for different tasks

  Quattro meta-learners adattano gli studenti progettati per un tipo di attività a un altro. ClassificationViaRegression esegue la classificazione utilizzando un metodo di regressione binarizzando la classe e costruendo un modello di regressione per ogni valore. Regressione-ByDiscretization è uno schema di regressione che discretizza l'attributo di classe in un numero specifico di contenitori utilizzando la discretizzazione a larghezza uguale e poi impiega un classificatore. Le previsioni sono la media ponderata del valore della classe media per ogni intervallo discretizzato, con pesi basati sulle probabilità previste per gli intervalli. OrdinalClassClassifier applica algoritmi di classificazione standard ai problemi della classe ordinale (Frank e Hall 2001). MultiClassClassifier gestisce i problemi multiclasse con classificatori a due classi utilizzando uno di questi metodi:







1. Uno contro tutto il resto
2. Classificazione a palo utilizzando il voto per prevedere
3. Codici di correzione errori esaustivi (Sezione 7.5, pagina 334)
4. Codici di correzione errori selezionati in modo casuale


 I vettori di codice casuale sono noti per avere buone proprietà di correzione degli errori: un parametro specifica la lunghezza del vettore di codice (in bit).
     Clustering algorithms

  La tabella 10.7 elenca gli algoritmi di clustering di Weka; I primi due e SimpleKMeans sono descritti nella sezione 6.6. Per l'implementazione di EM è possibile specificare quanti cluster da generare o l'algoritmo può decidere utilizzando la convalida incrociata, nel qual caso il numero di pieghe è fissato a 10 (a meno che non ci siano meno di 10 istanze di formazione). È possibile specificare il numero massimo di iterazioni e impostare la deviazione standard minima consentita per il calcolo normale di densità.
   SimpleKMeans raggruppa i dati utilizzando k-means; Il numero di cluster è specificato da un parametro. Cobweb implementa sia l'algoritmo Cobweb per gli attributi nominali che l'algoritmo Classit per gli attributi numerici. L'ordinazione e la priorità degli operatori di fusione e divisione differiscono tra i documenti originali Cobweb e Classit (dove è un po 'ambiguo). Questa implementazione confronta sempre quattro modi diversi di trattare una nuova istanza e sceglie il meglio: aggiungendolo al miglior host, trasformandolo in una nuova foglia, fondendo i due migliori host e aggiungendolo al nodo unito e dividendo il miglior host e Aggiungendolo a una delle divisioni. Acuità e cutoff sono parametri.
   FarthestFirst implementa l'algoritmo traversale di Hochbaum e Shmoys (1985), citato da Sanjoy Dasgupta (2002); Un clusterer veloce, semplice e approssimativo, modellato su k-means. MakeDensityBasedClusterer è un meta-clusterer che avvolge un algoritmo di clustering per renderlo restituito una distribuzione e una densità di probabilità. Ad ogni cluster è adatta a una distribuzione discreta oa una distribuzione normale simmetrica (la cui deviazione standard minima è un parametro)
     Association-rule learners

  Weka possiede tre studenti di regole di associazione, elencati nella tabella 10.8. Apriori implementa l'algoritmo Apriori (Sezione 4.5). Comincia con un supporto minimo del 100% delle voci di dati e lo diminuisce in passi del 5% finché non ci sono almeno 10 regole con la minima riservatezza necessaria di 0,9 o fino a quando il supporto ha raggiunto un limite inferiore del 10%, qualunque si verifichi per primo. (Questi valori predefiniti possono essere modificati.) Ci sono quattro metriche alternative per regole di classificazione: la fiducia, che è la proporzione degli esempi coperti dalla premessa che sono anche coperti dalla conseguente (chiamata precisione nella sezione 4.5); Ascensore, determinato dividendo la fiducia dal supporto (chiamata copertura nella sezione 4.5); Sfruttamento, che è la proporzione di esempi aggiuntivi coperti sia dalla premessa che dai conseguenti al di là di quelli attesi se la premessa e conseguenti sono stati statisticamente indipendenti; E Conviction, una misura definita da Brin et al. (1997). È inoltre possibile specificare un livello di significatività e le norme saranno testate per significatività a questo livello.

   PredictiveApriori combina fiducia e supporto in una sola misura di precisione predittiva (Scheffer 2001) e trova le migliori regole di associazione n in ordine. All'interno, l'algoritmo aumenta successivamente la soglia di sostegno, in quanto il valore della precisione predittiva dipende da esso. Tertius trova regole secondo una misura di conferma (Flach e Lachiche 1999), cercando regole con molteplici condizioni nel conseguente, come Apriori, ma differente in quanto queste condizioni sono OR insieme, non ANDed. Può essere impostato per trovare le regole che prevedono una singola condizione o un attributo predeterminato (cioè le regole di classificazione). Un parametro determina se la negazione è consentita negli antecedenti, nei conseguenti o entrambi; Altri forniscono il numero di regole richieste, il minimo grado di conferma, la copertura minima, la percentuale massima di contromisure e la dimensione massima della regola. I valori mancanti possono corrispondere a qualsiasi valore, non corrispondere mai, o essere significativi e potrebbero apparire nelle regole.
    Attribute selection

  La Figura 10.21 mostra la parte del pannello di selezione degli attributi di Weka in cui si specifica il criterio di attributo e il metodo di ricerca; La tabella 10.9 e la tabella 10.10 elencano le scelte. La selezione degli attributi avviene normalmente eseguendo la ricerca dello spazio dei sottotitoli degli attributi, valutando ciascuno di essi (Sezione 7.1). Ciò è ottenuto combinando uno dei quattro valutatori di sottoinsieme di attributi nella tabella 10.9 con uno dei sette metodi di ricerca nella tabella 10.10. Un approccio potenzialmente più veloce ma meno accurato è quello di valutare individualmente gli attributi e di ordinarli, eliminando gli attributi che scendono al di sotto di un punto di interruzione scelto. Ciò è ottenuto selezionando uno degli otto valutatori a singolo attributo nella tabella 10.9 e utilizzando il metodo di classificazione nella tabella 10.10. L'interfaccia Weka consente entrambe le possibilità consentendo all'utente di scegliere un metodo di selezione dalla tabella 10.9 e da un metodo di ricerca della tabella 10.10, generando un messaggio di errore se si seleziona una combinazione inappropriata. La riga di stato ti riferisce al registro degli errori del messaggio (vedere la fine della sezione 10.1).

  La Figura 10.21 mostra la parte del pannello di selezione degli attributi di Weka in cui si specifica il criterio di attributo e il metodo di ricerca; La tabella 10.9 e la tabella 10.10 elencano le scelte. La selezione degli attributi avviene normalmente eseguendo la ricerca dello spazio dei sottotitoli degli attributi, valutando ciascuno di essi (Sezione 7.1). Ciò è ottenuto combinando uno dei quattro valutatori di sottoinsieme di attributi nella tabella 10.9 con uno dei sette metodi di ricerca nella tabella 10.10. Un approccio potenzialmente più veloce ma meno accurato è quello di valutare individualmente gli attributi e di ordinarli, eliminando gli attributi che scendono al di sotto di un punto di interruzione scelto. Ciò è ottenuto selezionando uno degli otto valutatori a singolo attributo nella tabella 10.9 e utilizzando il metodo di classificazione nella tabella 10.10. L'interfaccia Weka consente entrambe le possibilità consentendo all'utente di scegliere un metodo di selezione dalla tabella 10.9 e da un metodo di ricerca della tabella 10.10, generando un messaggio di errore se si seleziona una combinazione inappropriata. La riga di stato ti riferisce al registro degli errori del messaggio (vedere la fine della sezione 10.1).
    Attribute subset evaluators

  I valutatori del sottoinsieme prendono un sottoinsieme di attributi e restituiscono una misura numerica che guida la ricerca. Sono configurati come qualsiasi altro oggetto Weka. CfsSubsetEval valuta l'abilità predittiva di ciascun attributo singolarmente e il grado di ridondanza tra di essi, preferendo gruppi di attributi altamente correlati con la classe ma hanno una bassa intercorrelazione (Sezione 7.1). Un'opzione aggiorna iterativamente gli attributi che hanno la massima correlazione con la classe, a condizione che l'insieme non contiene già un attributo la cui correlazione con l'attributo in questione è ancora più alta. La mancanza può essere considerata come un valore separato, oppure i suoi conteggi possono essere distribuiti tra altri valori in proporzione alla loro frequenza. ConsistencySubsetEval valuta gli attributi impostati per il grado di coerenza nei valori di classe quando le istanze di formazione sono proiettate sul set. La coerenza di qualsiasi sottoinsieme di attributi non può mai migliorare rispetto a quella del set completo, in modo che questo valutatore venga usualmente utilizzato in combinazione con una ricerca casuale o esaustiva che cerca il più piccolo sottogruppo la cui coerenza è uguale a quella del set completo di attributi.

  Mentre i valutatori di sottoinsiemi precedentemente menzionati sono i metodi di filtrazione della selezione degli attributi (Sezione 7.1), i restanti sono i metodi wrapper. ClassifierSubsetEval utilizza un classificatore, specificato nell'editor di oggetti come parametro, per valutare set di attributi sui dati di addestramento o su un set di holdout separato. WrapperSubsetEval utilizza anche un classificatore per valutare i set di attributi, ma utilizza la convalida incrociata per stimare l'accuratezza dello schema di apprendimento per ciascun set.
     Single-attribute evaluators

   I valutatori a un attributo vengono utilizzati con il metodo di ricerca Ranker per generare un elenco classificato da cui Ranker scarta un dato numero (spiegato nella sottosezione successiva). Possono essere utilizzati anche nel metodo RankSearch. ReliefFAttributeEval è basato su istanza: esegue istanze casuali e controlla istanze vicine delle stesse e diverse classi (Sezione 7.1). Funziona su dati di classe discreti e continui. Parametri specificano il numero di istanze da campionare, il numero di vicini da controllare, se pesare i vicini per distanza e una funzione esponenziale che governa quanto velocemente i pesi decadono con la distanza.

  InfoGainAttributeEval valuta gli attributi misurando il loro guadagno di informazioni rispetto alla classe. Discretizza gli attributi numerici innanzitutto utilizzando il metodo di discretizzazione basato su MDL (può essere impostato per binarizzare invece). Questo metodo, insieme ai tre successivi, può trattare mancanti come un valore separato o distribuire i conteggi tra altri valori in proporzione alla loro frequenza. ChiSquaredAttributeEval valuta gli attributi computando la statistica chi-squared rispetto alla classe. GainRatioAttributeEval valuta gli attributi misurando il loro rapporto di guadagno rispetto alla classe. SymmetricalUncertAttributeEval valuta un attributo A misurando la sua incertezza simmetrica rispetto alla classe C (Sezione 7.1, pagina 291).

OneRAttributeEval utilizza la misura di precisione semplice adottata dal OneRclassifier. Può utilizzare i dati di formazione per la valutazione, come OneR, oppure può applicare la convalida interna: il numero di pieghe è un parametro. Adotta il metodo di discretizzazione di OneR: la dimensione minima della benna è un parametro.

  SVMAttributeEval valuta gli attributi utilizzando l'eliminazione delle funzionalità ricorsive con una macchina vettoriale lineare di supporto (Sezione 7.1, pagina 291). Gli attributi sono selezionati uno per uno in base alla dimensione dei loro coefficienti, ricognendo dopo ciascuno. Per accelerare le cose, un numero fisso (o proporzione) di attributi può essere rimosso in ogni fase. Infatti, una percentuale può essere utilizzata fino a quando un certo numero di attributi rimangono, passando poi al metodo del numero fisso - eliminando rapidamente molti attributi e poi considerando ciascuno di essi in modo più intenso. Vari parametri vengono passati alla macchina vettore di supporto: complessità, epsilon, tolleranza e il metodo di filtraggio utilizzato.A differenza di altri valutatori a singolo attributo, PrincipalComponents trasforma l'insieme di attributi. I nuovi attributi sono classificati in ordine dei loro valori di origine (Sezione 7.3, pagina 306); Facoltativamente, viene selezionato un sottoinsieme scegliendo sufficienti autovettori per rappresentare una determinata percentuale della varianza (95% per impostazione predefinita). Puoi anche usarlo per trasformare i dati ridotti nello spazio originale.
   Search methods

  I metodi di ricerca attraversano lo spazio attributo per trovare un buon sottoinsieme. La qualità viene misurata dal valutatore di sottoinsieme degli attributi scelti. Ogni metodo di ricerca può essere configurato con l'editor di oggetti di Weka. BestFirst esegue arrampicata grezza con backtracking; È possibile specificare quanti nodi non-migliorati consecutivi devono essere rilevati prima che il backtracks del sistema venga eseguito. Può eseguire la ricerca in avanti dall'insieme vuoto di attributi, all'indietro dall'insieme completo oa partire da un punto intermedio (specificato da un elenco di indici di attributo) e la ricerca in entrambe le direzioni considerando tutte le eventuali aggiunte e cancellazioni a un attributo.I sottogruppi che sono stati valutati vengono memorizzati per efficienza; La dimensione della cache è un parametro.

  GreedyStepwise cerca con avidità lo spazio dei sottotitoli di attributi. Come BestFirst, può avanzare avanti dal set vuoto o indietro dal set completo. A differenza di BestFirst, non viene eseguito il backup ma termina non appena aggiungendo o eliminando il miglior attributo restante diminuisce la metrica di valutazione. In una modalità alternativa, classifica gli attributi attraversando lo spazio da vuoto a pieno (o viceversa) e registrando l'ordine in cui gli attributi sono selezionati. È possibile specificare il numero di attributi per mantenere o impostare una soglia al di sotto del quale gli attributi vengono scartati.
  La ricerca di corsa, usata con ClassifierSubsetEval, calcola l'errore di convalida incrociata dei sottoinsiemi di attributi concorrenti utilizzando la ricerca di corsa (Sezione 7.1). Le quattro diverse ricerche descritte a pagina 295 vengono implementate: selezione avanti, eliminazione all'indietro, ricerca di scansioni e racing di rango. Nell'ultimo caso, un valutatore di attributo separato (che può anche essere specificato) viene utilizzato per generare una graduatoria iniziale. Utilizzando la selezione in avanti, è anche possibile generare un elenco di attributi classificato dalla corsa continua finché non sono stati selezionati tutti gli attributi: la classifica è impostata sull'ordine in cui vengono aggiunti. Come con GreedyStepwise, è possibile specificare il numero di attributi per mantenere o impostare una soglia al di sotto del quale gli attributi vengono scartati.

  GeneticSearch utilizza un semplice algoritmo genetico (Goldberg 1989). Parametri includono la dimensione della popolazione, il numero di generazioni e le probabilità di crossover e mutazione. È possibile specificare un elenco di indici di attributo come punto di partenza, che diventa membro della popolazione iniziale. I rapporti di avanzamento possono essere generati ogni tante generazioni. RandomSearch ricerca casualmente lo spazio dei sottotitoli di attributo. Se viene fornito un set iniziale, esegue la ricerca di sottoinsiemi che migliorano (o uguagli) il punto di partenza e hanno meno (o lo stesso numero di) attributi. Altrimenti, inizia da un punto casuale e segnalerà il miglior sottoinsieme trovato. Il posizionamento di tutti gli attributi nel set iniziale rende algoritmo di selezione probabilistica di Liu e Setiono (1996). È possibile determinare la frazione dello spazio di ricerca da esplorare. ExhaustiveSearch ricerca attraverso lo spazio dei sottotitoli di attributo, a partire dall'insieme vuoto e segnalerà il miglior sottoinsieme trovato. Se viene fornito un set iniziale, cerca da questo punto di partenza e segnalerà il sottoinsieme più piccolo con una valutazione migliore (o uguale).
   RankSearch ordina gli attributi utilizzando un singolo attributo valutatore e quindi elenca sottoinsiemi promettenti utilizzando un valutatore di sottotitoli di attributo. Quest'ultimo è specificato nella casella superiore della Figura 10.21, come al solito; Il valutatore di attributo viene specificato come una proprietà nell'editor di oggetto RankSearch. Comincia ordinando gli attributi con il singolo attributo valutatore e quindi valuta i sottoinsiemi di dimensioni crescenti utilizzando il valutatore del sottoinsieme: il miglior attributo, il miglior attributo più il successivo migliore, e così via, segnalando il miglior sottoinsieme. Questa procedura ha una bassa complessità computazionale: il numero di volte in cui entrambi i valutatori sono chiamati è lineare nel numero di attributi. Utilizzando un semplice singolo attributo di valutazione (ad esempio, GainRatioAttributeEval), la procedura di selezione è molto veloce.

  Finally we describe Ranker, which as noted earlier is not a search method for attribute subsets but a ranking scheme for individual attributes. Determina gli attributi per le loro valutazioni individuali e deve essere utilizzato in combinazione con uno dei valutatori a un attributo nella parte inferiore della Tabella 10.9 - non un valutatore di sottotitoli di attributo. Il Ranker non solo classifica gli attributi, ma esegue anche la selezione degli attributi rimuovendo quelli inferiori. È possibile impostare una soglia di intervallo al di sotto del quale gli attributi vengono scartati o specificare quanti attributi da conservare. È possibile specificare alcuni attributi che devono essere conservati indipendentemente dal loro rango.
           The Knowledge Flow Interface

    Con l'interfaccia Knowledge Flow, gli utenti selezionano i componenti Weka da una barra degli strumenti, li posizionano su una tela di layout e li collegano in un grafico diretto che elabora e analizza i dati. Fornisce un'alternativa all'Explorer per coloro che amano pensare in termini di flusso di dati attraverso il sistema. Consente inoltre la progettazione e l'esecuzione di configurazioni per l'elaborazione dati in streaming, che l'Explorer non può fare. Si invoca l'interfaccia Knowledge Flow selezionando KnowledgeFlow dalle scelte in fondo al pannello mostrato nella Figura 10.3 (a).
    Getting started

  Ecco un esempio passo per passo che carica un file ARFF e esegue una convalida incrociata utilizzando J4.8. Descriviamo come costruire la configurazione finale mostrata in Figura 11.1. Innanzitutto creare una fonte di dati facendo clic sulla scheda DataSources (voce più a destra nella barra in alto) e selezionando ARFFLoader dalla barra degli strumenti. Il cursore del mouse cambia in crosshairs per segnalare che dovresti posizionare il componente successivamente. Fai clic su un punto qualsiasi sulla tela, quindi compare una copia dell'icona del caricatore ARFF. Per collegarlo ad un file ARFF, fare clic con il pulsante destro del mouse per visualizzare il menu a comparsa mostrato in Figura 11.2 (a). Fare clic su Configura per ottenere il browser di file in Figura 11.2 (b), da cui si seleziona il file ARFF desiderato. Il menu a discesa Formato file consente di scegliere un diverso tipo di origine dati, ad esempio i file di fogli di calcolo.
   Adesso specifichiamo quale attributo è la classe usando un oggetto ClassAssigner. Questo è nel pannello Valutazione, quindi fare clic sulla scheda Valutazione, selezionare ClassAssigner e inserirlo sulla tela. Per collegare l'origine dati all'assegnazione di classe, fare clic con il pulsante destro del mouse sull'icona dell'origine dati e selezionare il set di dati dal menu, come mostrato in Figura 11.2 (a). Viene visualizzata una riga di gomma. Spostare il mouse sopra il componente di assegnazione della classe e fare clic con il pulsante sinistro. Viene visualizzata una linea rossa denominata set di dati, unendo i due componenti. Dopo aver collegato l'assegnatore di classe, scegliere la classe facendo clic con il pulsante destro del mouse, selezionando Configura e inserendo la posizione dell'attributo di classe.

  Effettuiamo la convalida incrociata sul classificatore J48. Nel modello di flusso di dati, è necessario collegare la CrossValidationFoldMaker per creare le pieghe su cui verrà eseguito il classificatore e quindi passare l'output a un oggetto che rappresenta J48. Cross-ValidationFoldMaker è sul pannello Valutazione. Selezionarlo, inserirlo sulla tela e collegarlo all'assistente di classe facendo clic con il pulsante destro del mouse su quest'ultimo e selezionando il set di dati dal menu (che è simile a quello in Figura 11.2 (a)). Avanti selezionare J48 dal pannello Classifiers e posizionare un componente J48 sulla tela. Ci sono così tanti classificatori differenti che devi scorrere lungo la barra degli strumenti per trovarlo. Connettere J48 al creatore di piegatura a croce di convalida nel modo consueto, ma fai due volte la connessione scegliendo di courseSet e quindi scegliendo testSet dal menu a comparsa per il creatore di piegatura di convalida incrociata. Il passo successivo è quello di selezionare un ValutazionePerformanceEvaluator dal pannello Valutazione e collegare J48 ad esso selezionando la voce batchClassifier dal menu a comparsa per J48. Infine, dalla barra degli strumenti di visualizzazione, posiziona un componente TextViewer sulla tela. Connettere il valutatore delle prestazioni del classificatore selezionando la voce di testo dal menu a comparsa per il valutatore delle prestazioni.
   A questo punto la configurazione è come mostrato nella Figura 11.1 a meno che non esiste ancora nessun visualizzatore di grafici. Avviare il flusso di esecuzione selezionando Caricamento inizio dal menu a comparsa per il caricatore ARFF, mostrato nella Figura 11.2 (a). Per un piccolo set di dati, le cose succedono rapidamente, ma se l'input è grande, si vedrà che alcune delle icone sono animate: ad esempio, l'albero di J48 sembra crescere e i segni di spunta del valutatore di prestazioni lampeggiano. Le informazioni di avanzamento vengono visualizzate nella barra di stato nella parte inferiore dell'interfaccia. La scelta dei risultati di visualizzazione dal menu a comparsa del visualizzatore di testo porta i risultati della convalida incrociata in una finestra separata, nella stessa forma di Explorer.

   Per completare l'esempio, aggiungere un GraphViewer e collegarlo all'output del grafico J48 per visualizzare una rappresentazione grafica degli alberi prodotti per ciascuna piega della cross-Validation. Una volta ripristinata la convalida incrociata con questo componente aggiuntivo, selezionando Mostra risultati dal menu a comparsa viene creato un elenco di alberi, uno per ogni piattaforma di convalida incrociata. Creando pieghe di validazione incrociate e passandole al classificatore, il modello Knowledge Flow fornisce un modo per associare i risultati a ciascuna piega. L'Explorer non può farlo: tratta la convalida incrociata come un metodo di valutazione applicato all'uscita di un classificatore.
      The Knowledge Flow components

  La maggior parte dei componenti Knowledge Flow avrà familiarità con l'Explorer. Il pannello Classifiers contiene tutti i classificatori di Weka, il pannello Filtri contiene i filtri e il pannello Clusterers contiene i cluster. Le fonti di dati possibili sono i file ARFF, i file CSV esportati da fogli di calcolo, il formato di file C4,5 e un loader di istanza serializzato per i file di dati salvati come un'istanza di un oggetto Java. Ci sono sincronizzazioni di dati e sorgenti per i formati di file supportati dall'Explorer. Esiste inoltre un data sink e un'origine dati che possono connettersi a un database.
    I componenti per la visualizzazione e la valutazione, elencati nella tabella 11.1, non sono ancora stati rilevati. In visualizzazione, DataVisualizer apre un pannello per visualizzare i dati in una trama bidimensionale di dispersione come nella figura 10.6 (b), in cui è possibile selezionare gli attributi che si desidera visualizzare. ScatterPlotMatrix apre una matrice di diagrammi di dispersione bidimensionale per ogni coppia di attributi, mostrata nella Figura 10.16 (a). AttributeSummarizer fornisce una matrice di istogrammi, uno per ogni attributo, come quello nell'angolo inferiore destro della Figura 10.3 (b). ModelPerformanceChart disegna curve ROC e altre curve di soglia.
   GraphViewer apre un pannello per visualizzare i modelli basati sugli alberi, come nella Figura 10.6 (a). Come in precedenza, è possibile ingrandire, pan e visualizzare i dati di istanza in un nodo (se è stato salvato dall'algoritmo di apprendimento). StripChart è un nuovo componente di visualizzazione progettato per l'utilizzo con l'apprendimento incrementale. In combinazione con l'IncrementalClassifierEvaluator descritto nel prossimo paragrafo, viene visualizzata una curva di apprendimento che precisa la precisione - sia l'accuratezza percentuale che l'errore di probabilità medio-quadrato - rispetto al tempo. Mostra una finestra temporale a dimensioni fisse che scorre orizzontalmente per rivelare gli ultimi risultati.

  Il pannello Valutazione contiene i componenti elencati nella parte inferiore della tabella 11.1. Il TrainingSetMaker e TestSetMaker creano un set di dati nel tipo di set corrispondente. CrossValidationFoldMaker costruisce le pieghe di convalida incrociate da un set di dati; TrainTestSplitMaker lo divide in set di addestramento e test tenendo parte dei dati fuori per il set di test. Il ClassAssigner consente di decidere quale attributo è la classe. Con ClassValuePicker si sceglie un valore che viene trattato come classe positiva quando genera ROC e altre curve di soglia. The ClassifierPerformanceEvaluator raccoglie statistiche di valutazione: può inviare la valutazione testuale a un visualizzatore di testo e le curve di soglia a una tabella delle prestazioni. L'IncrementalClassifierEvaluator esegue la stessa funzione per i classificatori incrementali: calcola gli errori quadrati in esecuzione e così via. C'è anche un ClustererPerformanceEvaluator, che è simile a ClassifierPerformanceEvaluator. PredictionAppender prende un classificatore e un set di dati e aggiunge le previsioni del classificatore al set di dati.
  Configuring and connecting the components

  È possibile stabilire il flusso di conoscenza configurando i singoli componenti e collegandoli. La Figura 11.3 mostra le operazioni tipiche disponibili facendo clic con il pulsante destro del mouse sui vari tipi di componenti. Questi menu hanno fino a tre sezioni: Modifica, Connessioni e Azioni. Le operazioni Edit eliminano i componenti e aprono il loro pannello di configurazione. I classificatori ei filtri sono configurati come nell'esploratore. Le sorgenti dati vengono configurate aprendo un file (come abbiamo visto in precedenza) e i componenti di valutazione sono configurati impostando parametri come il numero di pieghe per la convalida incrociata. Le operazioni Azioni sono specifiche per quel tipo di componente, come ad esempio iniziare a caricare dati da un'origine dati o ad aprire una finestra per mostrare i risultati della visualizzazione. Le operazioni Connessioni vengono utilizzate per collegare i componenti insieme selezionando il tipo di connessione dal componente di origine e quindi facendo clic sull'oggetto di destinazione. Non tutti gli obiettivi sono adatti; Vengono evidenziati quelli applicabili. Le voci del menu connessioni vengono disattivate (in grigio) finché il componente riceve altre connessioni che li rendono applicabili.

   Esistono due tipi di connessione dalle origini dati: connessioni del set di dati e connessioni di istanze. Le prime sono per operazioni di batch come classificatori come J48; Questi ultimi sono per operazioni di flusso come NaiveBayesUpdateable. Un componente di origine dati non è in grado di fornire entrambi i tipi di connessione: una volta selezionato, l'altro viene disattivato. Quando una connessione di un set di dati viene effettuata a un classificatore di batch, il classificatore deve sapere se è destinato a servire come un set di formazione o un set di test. A tale scopo, prima di eseguire l'origine dati in un set di test o formazione, utilizzare i componenti TestSetMaker o TrainingSetMaker dal pannello Valutazione. D'altra parte, una connessione di istanza a un classificatore incrementale è fatta direttamente: non vi è alcuna distinzione tra formazione e test, perché le istanze che flusso aggiornano il classificatore in modo incrementale. In questo caso viene effettuata una previsione per ogni istanza in ingresso e incorporata nei risultati del test; Allora il classificatore è addestrato in quell'istanza. Se si effettua una connessione di istanza a un classificatore batch, verrà utilizzata come istanza di prova perché la formazione non può essere incrementale, mentre il test può sempre essere. Al contrario, è abbastanza possibile testare un classificatore incrementale in modalità batch utilizzando una connessione del dataset.

  Le connessioni provenienti da un componente di filtro vengono abilitate quando riceve un input da un'origine dati, quindi è possibile eseguire il set di dati di follow-on o le connessioni di istanze. Le connessioni di istanza non possono essere effettuate su filtri sorvegliati o su filtri non pervisibili che non possono gestire i dati in modo incrementale (ad esempio Discretize). Per ottenere un test o una formazione impostati da un filtro, è necessario inserire il tipo appropriato. Il menu classifica contiene due tipi di connessione. Il primo tipo, cioè le connessioni di grafici e di testo, fornisce rappresentazioni grafiche e testuali dello stato di apprendimento del classificatore e viene attivato solo quando riceve un input di formazione. L'altro tipo, cioè le connessioni batchClassifier e incrementalClassifier, rende i dati disponibili a un valutatore delle prestazioni e viene attivato solo quando è presente un input di test set. Quale è attivato dipende dal tipo di classificatore.
  I componenti di valutazione sono una borsa mista. TrainingSetMaker e TestSetMaker trasformano un set di dati in un set di formazione o test. CrossValidationFoldMaker trasforma un set di dati sia in un set di formazione che in un set di test. ClassifierPerformanceEvaluator (utilizzato nell'esempio di Sezione 11.1) genera output testuale e grafico per i componenti di visualizzazione. Altri componenti di valutazione funzionano come filtri: permettono il set di dati di follow-on, l'istanza, l'addestramento o le connessioni di test set in base all'ingresso (ad esempio ClassAssigner assegna una classe a un set di dati). I componenti di visualizzazione non dispongono di connessioni, anche se alcune hanno azioni come Mostra risultati e Cancella risultati.

    Incremental learning

   In molti casi l'interfaccia Knowledge Flow è funzionalmente simile all'Explorer: puoi fare cose simili con entrambe. Fornisce una certa flessibilità aggiuntiva - ad esempio, è possibile vedere l'albero che J48 fa per ciascuna piega di conferma della croce. Ma la sua vera forza è il potenziale per un funzionamento incrementale.

   Weka ha diversi classificatori che possono gestire i dati in modo incrementale: AODE, una versione di studenti Naïve Bayes (NaiveBayesUpdateable), Winnow e basati su istanze (IB1, IBk, KStar, LWL). Il metalearner RacedIncrementalLogitBoost funziona in modo incrementale (pagina 416). Tutti i filtri che esegue l'istanza per esempio sono incrementali: Aggiungi, AddExpression, Copia, FirstOrder, MakeIndicator, Merge-TwoValues, NonSparseToSparse, NumericToBinary, NumericTransform, Obfuscate, RemoveType, RemoveWithValues, SparseToNonSparse e SwapValues. Se tutti i componenti collegati nell'interfaccia di flusso di conoscenza funzionano in modo incrementale, il sistema di apprendimento risulta così. Non si legge nel dataset prima dell'inizio dell'apprendimento, come esegue l'Explorer. Invece, il componente di origine dati legge l'istanza di input per istanza e lo passa attraverso la catena Knowledge Flow.

   La Figura 11.4 (a) mostra una configurazione che funziona in modo incrementale. Una connessione di istanza viene eseguita dal caricatore al classificatore Naïve Bayes aggiornabile. L'output del testo del classificatore viene portato a un visualizzatore che fornisce una descrizione testuale del modello. Inoltre, viene effettuata una connessione incrementalClassifier al valutatore di prestazioni corrispondente. Ciò produce un'uscita di tipo grafico, che viene piped in un componente di visualizzazione grafico a striscia per generare una traccia di dati a scorrimento.

   La Figura 11.4 (b) mostra l'output della tabella a nastro. Compila sia l'accuratezza che l'errore di probabilità medio-quadrato di root rispetto al tempo. Quando il tempo passa, l'intera trama (compresi gli assi) si sposta a sinistra per fare spazio a nuovi dati sulla destra. Quando l'asse verticale che rappresenta il tempo 0 può muoversi a sinistra non più, si ferma e l'origine del tempo inizia ad aumentare da 0 per mantenere il passo con i dati in arrivo a destra. Quindi, quando il grafico è pieno, mostra una finestra delle unità di tempo più recenti. Il grafico a strisce può essere configurato per modificare il numero di istanze visualizzate sull'asse x.

   Questa configurazione Knowledge Flow particolare può elaborare file di input di qualsiasi dimensione, anche quelli che non si inseriscono nella memoria principale del computer. Tuttavia, tutto dipende da come il classificatore opera internamente. Ad esempio, anche se sono incrementali, molti studenti basati sull'istanza memorizzano internamente l'intero set di dati.
      The Experimenter

Gli ambienti Explorer e Knowledge Flow consentono di determinare in che modo i sistemi di apprendimento delle macchine eseguono su determinati set di dati. Ma i lavori di indagine gravi comportano esperienze sostanziali, in genere eseguendo diversi schemi di apprendimento su set di dati diversi, spesso con varie impostazioni dei parametri, e queste interfacce non sono realmente adatte per questo. Il Experimenter ti consente di impostare esperimenti su larga scala, avviarli in esecuzione, lasciarli e tornare quando finiscono e analizzeranno le statistiche sulle prestazioni che sono state raccolte. Esse automatizzano il processo sperimentale. Le statistiche possono essere memorizzate in formato ARFF e possono essere oggetto di ulteriore data mining. Si invoca questa interfaccia selezionando Experimenter dalle scelte nella parte inferiore del pannello di Figura 10.3 (a).

Mentre il flusso di conoscenza trascende le limitazioni dello spazio, consentendo di eseguire operazioni di apprendimento automatico che non si caricano in un insieme di dati contemporaneamente, il Experimenter trascende le limitazioni del tempo. Contiene strutture per gli utenti avanzati di Weka per distribuire il carico di calcolo su più macchine utilizzando Java RMI. È possibile impostare grandi esperimenti e lasciarli correre.
  Getting started

  Ad esempio, confronteremo il metodo dell'albero decisionale J4.8 con i metodi di base OneR e ZeroR sul dataset Iris. Il Experimenter dispone di tre pannelli: Setup, Esegui e Analizza. La Figura 12.1 (a) mostra la prima: seleziona gli altri dalle schede in alto. Qui, l'esperimento è già stato impostato. Per fare questo, fai clic su Nuovo (verso destra in alto) per avviare un nuovo esperimento (gli altri due pulsanti in quella riga salvano un esperimento e aprono uno precedentemente salvato). Quindi, nella riga sottostante, selezionare la destinazione dei risultati - in questo caso il file Experiment1 - e scegliere il file CSV. Sotto, selezionare i set di dati, abbiamo solo uno, i dati dell'iride. A destra dei set di dati, selezionare gli algoritmi da testare, abbiamo tre. Fare clic su Aggiungi nuovo per ottenere un editor di oggetti standard Weka da cui è possibile scegliere e configurare un classificatore. Ripetere questa operazione per aggiungere i tre classificatori. Ora l'esperimento è pronto. Le altre impostazioni mostrate nella Figura 12.1 (a) sono tutti valori predefiniti. Se si desidera riconfigurare un classificatore già presente nell'elenco, è possibile utilizzare il pulsante Modifica selezionato. È inoltre possibile salvare le opzioni per un determinato classificatore in formato XML per il successivo riutilizzo.

  Figure 12.1 An experiment:
          Running an experiment

  Per eseguire l'esperimento, fare clic sulla scheda Esegui, che visualizza un pannello che contiene un pulsante di avvio (e poco altro); cliccalo. Una breve relazione viene visualizzata quando l'operazione è terminata. Il file Experiment1.csv contiene i risultati. Le prime due righe sono illustrate nella Figura 12.1 (b): sono in formato CSV e possono essere lette direttamente in un foglio di calcolo, la prima parte della quale figura nella Figura 12.1 (c). Ogni riga rappresenta 1 passaggio di una convalida incrociata di 10 volte (vedere la colonna Piega). La convalida incrociata viene eseguita 10 volte (la colonna Esegui) per ogni classificatore (la colonna Schema). Così il file contiene 100 righe per ogni classificatore, che rende 300 righe in tutto (più la riga di intestazione). Ogni riga contiene molte informazioni - 46 colonne, infatti - incluse le opzioni fornite allo schema di apprendimento macchina; Il numero di istituti di formazione e di prova; Il numero (e la percentuale) di istanze corrette, non corrette e non classificate; L'errore assoluto medio, l'errore medio-quadrato root e molti altri. C'è una grande quantità di informazioni nel foglio di calcolo, ma è difficile da digerire. In particolare, non è facile rispondere alla domanda posta in precedenza: come confronta J4.8 con i metodi di base OneR e ZeroR su questo set di dati? Per questo abbiamo bisogno del pannello Analizza.
       Analyzing the results

  Il motivo per cui abbiamo generato l'output in formato CSV è stato quello di mostrare il foglio di diffusione in Figura 12.1 (c). Il Experimenter normalmente produce la sua uscita in formato ARFF. È inoltre possibile lasciare vuoto il nome del file, nel qual caso l'Experimenter memorizza i risultati in un file temporaneo.

    Il pannello Analizza è mostrato in Figura 12.2. Per analizzare l'esperimento appena eseguito, fai clic sul pulsante Esperimento a destra vicino alla parte superiore; Altrimenti, fornire un file che contiene i risultati di un altro esperimento. Quindi fare clic su Esegui test (vicino alla parte inferiore a sinistra). Il risultato di un test di significatività statistica delle prestazioni del primo schema di apprendimento (J48) rispetto a quello degli altri due (OneR e ZeroR) verrà visualizzato nel pannello di grandi dimensioni a destra. Stiamo confrontando la percentuale statistica corretta: questa viene selezionata per impostazione predefinita come il campo di confronto mostrato verso sinistra di Figura 12.2. I tre metodi sono visualizzati orizzontalmente, numerati (1), (2) e (3) come titolo di una piccola tavola. Le etichette per le colonne vengono ripetute nei piani inferiori.J48, rules.OneR e rules.ZeroR - in caso non vi sia spazio sufficiente per loro nella voce. Gli interi inscrucibili accanto ai nomi del sistema identificano quale versione dello schema viene utilizzata. Essi sono presenti per impostazione predefinita per evitare confusione tra i risultati generati utilizzando diverse versioni degli algoritmi. Il valore tra parentesi all'inizio della riga dell'iride (100) è il numero di prove sperimentali: 10 volte la convalida incrociata di 10 volte

  La percentuale corretta per i tre schemi è riportata in Figura 12.2: 94,73% per il metodo 1, 93,53% per il metodo 2 e 33,33% per il metodo 3. Il simbolo posto accanto a un risultato indica che è Statisticamente migliore (v) o peggio (*) Rispetto allo schema di base - in questo caso J4.8 - al livello di significato specificato (0,05 o 5%). Viene utilizzato il test t-test riselezionato da Sezione 5.5 (pag.157). Qui il metodo 3 è significativamente peggiore del metodo 1, perché il suo tasso di successo è seguito da un asterisco. Nella parte inferiore delle colonne 2 e 3 sono conteggi (x / y / z) del numero di volte in cui lo schema era migliore di (x) uguale a (y) o peggiore di (z) lo schema di base nel set di Dati Utilizzati nell'esperimento. In questo caso esiste solo un set di dati; Il metodo 2 era equivalente al metodo 1 (la linea di base) una volta, e il metodo 3 era più grave di una volta. (L'annotazione (v / / *) è posta in fondo alla colonna 1 per aiutarti a ricordare i significati dei tre conteggi x / y / z.)
        Simple setup

  Nel pannello di installazione mostrato in Figura 12.1 (a) abbiamo lasciato la maggior parte delle opzioni ai valori predefiniti. L'esperimento è una convalida incrociata di 10 volte ripetuta 10 volte. È possibile modificare il numero di pieghe nella casella a sinistra centrale e il numero di ripetizioni nella casella a destra centrale. Il tipo di esperimento è classificazione; È possibile specificare invece la regressione. È possibile scegliere più set di dati, nel qual caso ciascun algoritmo viene applicato a ciascun set di dati e modificare l'ordine di iterazione utilizzando i primi pulsanti di dati prima e di Algoritmo. L'alternativa alla convalida incrociata è il metodo di holdout. Ci sono due varianti, a seconda che l'ordine del set di dati sia mantenuto o che i dati siano randomizzati. È possibile specificare la percentuale di divisione (l'impostazione predefinita è due terzi di formazione e un terzo set di test).
   Le impostazioni sperimentali possono essere salvate e riaperte. È possibile apprendere le impostazioni premendo il pulsante Note, che visualizza una finestra di modifica. Gli utenti seri di Weka scoprono presto la necessità di aprire un esperimento e di rieseguirlo con alcune modifiche, forse con un nuovo set di dati o un nuovo algoritmo di apprendimento. Sarebbe bello evitare di ricalcolare tutti i risultati già ottenuti! Se i risultati sono stati inseriti in un database piuttosto che un file ARFF o CSV, questo è esattamente quello che accade. È possibile scegliere database JDBC nel selettore di destinazione dei risultati e connettersi a qualsiasi database con un driver JDBC. Devi specificare l'URL del database e immettere un nome utente e una password. Per fare questo lavoro con il tuo database, potrebbe essere necessario modificare il file weka / experiment / DatabaseUtils.props nella distribuzione Weka. Se si modifica un esperimento che utilizza un database, Weka riutilizza i risultati precedentemente calcolati ogni volta che sono disponibili. Questo semplifica notevolmente il tipo di sperimentazione iterativa che tipicamente caratterizza la ricerca di data mining.
     Advanced setup

  Lo sperimentatore ha una modalità avanzata. Fare clic vicino alla parte superiore del pannello mostrato nella Figura 12.1 (a) per ottenere la versione più formidabile del pannello mostrato in Figura 12.3. Ciò allarga le opzioni disponibili per controllare l'esperimento, inclusa, ad esempio, la capacità di generare curve di apprendimento. Tuttavia, la modalità avanzata è difficile da usare, e la versione semplice è sufficiente per la maggior parte degli scopi. Ad esempio, in modalità avanzata è possibile impostare un'iterazione per testare un algoritmo con una successione di valori diversi di parametri, ma lo stesso effetto può essere raggiunto in modalità semplice mettendo più volte l'algoritmo nell'elenco con diversi valori di parametro. Qualcosa che potrebbe essere necessario per la modalità avanzata per è impostare esperimenti distribuiti, che descriviamo nella sezione 12.5.
     The Analyze panel

   Il nostro passaggio ha utilizzato il pannello Analizza per eseguire un test di significato statistico di uno schema di apprendimento (J48) rispetto a due altri (OneR e ZeroR). Il test era sul tasso di errore: il campo di confronto in Figura 12.2. Le altre statistiche possono essere selezionate dal menu a discesa invece: percentuale non corretta, percentuale non classificata, errore medio medio quadrato, altre misure di errore dalla tabella 5.8 (pag. 178) e varie figure di entropia. Inoltre, è possibile vedere la deviazione standard dell'attributo che viene valutato selezionando la casella di controllo Mostra deviazioni std.
   Utilizza il menu Base di selezione per modificare lo schema di base da J4.8 a uno degli altri sistemi di apprendimento. Ad esempio, la selezione di OneR provoca l'confrontabilità degli altri con questo schema. In realtà, ciò mostrerebbe una differenza statisticamente significativa tra OneR e ZeroR ma non tra OneR e J48. Oltre ai sistemi di apprendimento, esistono altre due opzioni nel menu Select base: Riepilogo e Ranking. Il primo confronta ogni schema di apprendimento con ogni altro schema e stampa una matrice le cui celle contengono il numero di set di dati su cui uno è significativamente migliore dell'altro. Quest'ultimo classifica gli schemi in base al numero totale di set di dati che rappresentano vincite (>) e perdite (<) e stampa una tabella di lega. La prima colonna dell'uscita fornisce la differenza tra il numero di vittorie e il numero di perdite.

  I campi Riga e Colonna determinano le dimensioni della matrice di confronto. Facendo clic su Seleziona viene visualizzato un elenco di tutte le funzionalità che sono state misurate nell'esperimento, ovvero le etichette delle colonne del foglio di calcolo in Figura 12.1 (c). È possibile selezionare quali da utilizzare come righe e colonne della matrice. (La selezione non viene visualizzata nella casella Seleziona perché possono essere scelte contemporaneamente più parametri.) La Figura 12.4 mostra quali sono le voci selezionate per le righe e le colonne di Figura 12.2. Le due liste mostrano i parametri sperimentali (le colonne del foglio di calcolo). Il set di dati è selezionato per le righe (e in questo caso è solo uno, il set di dati Iris) e sono selezionati Schema, Scheme e Scheme_version_ID per la colonna (la convenzione abituale del selettore di selezione seleziona più voci). Tutti e tre si possono vedere nella Figura 12.2 - infatti, sono più facilmente leggibili nella chiave in basso.
   Se le selezioni di riga e colonna sono state scambiate e il pulsante Test di esecuzione è stato nuovamente premuto, la matrice sarebbe stata trasposta, dando il risultato alla figura 12.4 (c). Adesso esistono tre righe, una per ogni algoritmo e una colonna, per il singolo set di dati. Se invece la riga di Dataset è stata sostituita da Run e il test è stato eseguito nuovamente, il risultato sarebbe come nella Figura 12.4 (d). L'esecuzione si riferisce alle esecuzioni della convalida incrociata, di cui sono 10, quindi ci sono ora 10 righe. Il numero tra parentesi dopo ogni etichetta di riga (100 in Figura 12.4 (c) e 10 in Figura 12.4 (d)) è il numero di risultati corrispondenti a quella riga - in altre parole, il numero di misurazioni che partecipano alle medie visualizzate Le cellule in quella riga. C'è anche un pulsante che consente di selezionare un sottoinsieme di colonne da visualizzare (la colonna di base è sempre inclusa) e un'altra che consente di selezionare il formato di output: testo normale (predefinito), output per il sistema di composizione LaTeX e Formato CSV.
   Distributing processing over several machines

  Una caratteristica straordinaria del Experimenter è che può dividere un esperimento e distribuirlo attraverso diversi processori. Questo è per gli utenti avanzati di Weka ed è disponibile solo dalla versione avanzata del pannello di installazione. Alcuni utenti evitare di lavorare con questo pannello impostando l'esperimento sulla versione semplice e passando alla versione avanzata per distribuirlo, poiché la struttura dell'esperimento viene preservata quando si passa. Tuttavia, la distribuzione di un esperimento è una caratteristica avanzata e spesso è difficile. Ad esempio, le autorizzazioni di file e directory possono essere difficili da impostare.
  Distribuire un esperimento funziona meglio quando i risultati vengono tutti inviati a un database centrale selezionando il database JDBC come destinazione dei risultati nel pannello mostrato nella Figura 12.1 (a). Utilizza la funzione RMI e funziona con qualsiasi database con un driver JDBC. E 'stato testato su diversi database disponibili liberamente. In alternativa, è possibile istruire ogni host per salvare i risultati in un altro file ARFF e unire i file in seguito.

   Per distribuire un esperimento, ciascun host deve (1) avere installato Java, (2) avere accesso a tutti i set di dati che si sta utilizzando e (3) eseguire il server di esperimenti weka.experiment.RemoteEngine. Se i risultati vengono inviati a un database centrale, è necessario installare i driver JDBC appropriati su ciascun host. Ottenere tutto questo è la parte difficile di eseguire esperimenti distribuiti. Per avviare un server di sperimentazione del motore remoto in una macchina host, prima copiate remoteExperimentServer.jar dalla distribuzione Weka in una directory dell'host. Disimballalo con



jar xvf remoteExperimentServer.jar


Espande a due file: remoteEngine.jar, un file jar eseguibile che contiene il server di esperimento e remote.policy. Il file remote.policy consente l'autorizzazione del motore remoto per eseguire determinate operazioni, ad esempio la connessione a porte o l'accesso a una directory. Deve essere modificato per specificare percorsi corretti in alcune delle autorizzazioni; Questo è esplicativo quando si esamina il file. Per impostazione predefinita, specifica che il codice può essere scaricato sulla porta HTTP 80 da qualsiasi punto del Web, ma i motori remoti possono anche caricare il codice da un URL di file. Per disporre questo, deselezionare l'esempio e sostituire il percorso in modo appropriato. Anche i motori remoti devono essere in grado di accedere ai set di dati utilizzati in un esperimento (vedere la prima voce in remote.policy). I percorsi dei set di dati sono specificati nel Experimenter (cioè il client) e gli stessi percorsi devono essere applicabili nel contesto dei motori remoti. Per agevolare questo, potrebbe essere necessario specificare i percorsi relativi relativi selezionando la casella di selezione Utilizza percorsi relativi visualizzata nel pannello di installazione di Experimenter.



Per avviare il server motore remoto digitare


 java -classpath remoteEngine.jar:<path_to_any_jdbc_drivers>
      -Djava.security.policy=remote.policy weka.experiment.RemoteEngine


Dalla directory contenente remoteEngine.jar. Se tutto va bene vedrai questo messaggio (o qualcosa di simile):

   ...


Nonostante le apparenze iniziali, questa è una buona notizia! La connessione è stata rifiutata perché non era in esecuzione alcun registro RMI su quel server, e quindi il motore remoto è stato avviato. Ripetere il processo su tutti gli host. Non ha senso spostare più di un motore remoto su una macchina. Avviare l'Experimenter digitando


java -Djava.rmi.server.codebase=<URL_for_weka_code> weka.gui.experiment.Experimenter


  L'URL indica dove i motori remoti possono trovare il codice da eseguire. Se l'URL indica una directory (cioè quella che contiene la directory Weka) piuttosto che un file jar, deve terminare con il separatore di percorso (ad esempio, /).
   Il pannello di installazione avanzato di Experimenter nella Figura 12.3 contiene un piccolo riquadro a sinistra centrale che determina se un esperimento verrà distribuito o no. Questo è normalmente inattivo. Per distribuire l'esperimento, fare clic sulla casella di controllo per attivare il pulsante Hosts; Comparirà una finestra che chiede le macchine su cui distribuire l'esperimento. I nomi degli host devono essere pienamente qualificati (ad esempio, ml.cs.waikato.ac.nz).
   Dopo aver inserito gli host, configurare il resto dell'esperimento nel modo consueto (meglio ancora, configurarlo prima di passare alla modalità di impostazione avanzata). Quando l'esperimento viene avviato utilizzando il pannello Esegui, viene visualizzato il progresso dei subexperiment nei vari host, insieme a eventuali messaggi di errore.
  Distribuire un esperimento comporta la suddivisione in sottoesperimenti che RMI invia agli host per l'esecuzione. Per impostazione predefinita, gli esperimenti vengono partizionati dal set di dati, nel qual caso non ci possono essere più host di quelli esistenti. Quindi ogni sottoesperimento è autosufficiente: applica tutti gli schemi a un singolo set di dati. Un esperimento con solo alcuni set di dati può essere suddiviso per eseguire invece. Ad esempio, una convalida incrociata di 10 volte 10 volte dovrebbe essere suddivisa in 10 sottoesperimenti, 1 per ogni esecuzione.
    The Command-line Interface

  Nascoste dietro le interfacce interattive di Weka - l'Explorer, il Flusso della conoscenza e l'Experimenter - sono le sue funzionalità di base. È possibile accedere in forma grezzo tramite un'interfaccia a riga di comando. Selezionare Simple CLI dalle opzioni di interfaccia in fondo alla figura 10.3 (a) per visualizzare un pannello testuale semplice con una riga nella parte inferiore in cui inserire i comandi. In alternativa, utilizzare l'interfaccia di riga di comando del sistema operativo per eseguire direttamente le classi in weka.jar, nel qual caso è necessario impostare la variabile di ambiente CLASSPATH come spiegato nel file README di Weka.  
     Getting started

  All'inizio della Sezione 10.1 abbiamo usato l'Explorer per invocare lo studente J4.8 sui dati meteo. Per fare la stessa cosa nell'interfaccia della riga di comando digitare nella riga nella parte inferiore del pannello di testo. Questo incantesimo chiama la macchina virtuale Java (nel CLI semplice, Java è già caricato) e l'istruisce per eseguire J4.8. Weka è organizzata in pacchetti che corrispondono a una gerarchia di directory. Il programma da eseguire è chiamato J48 e risiede nel pacchetto di alberi, che è un sottofondo di classificatori, che fa parte del pacchetto weka globale.




 java weka.classifiers.trees.J48 -t data/weather.arff


    La sezione successiva fornisce ulteriori dettagli sulla struttura del pacchetto. L'opzione -t consente di indicare che l'argomento successivo è il nome del file di addestramento: supponiamo che i dati meteorologici risiedano in una sottodirectory dati della directory da cui hai sparato Weka. Il risultato assomiglia al testo mostrato nella Figura 10.5. Nel CLI semplice si visualizza nel pannello sopra la riga in cui è stato digitato il comando.
   The structure of Weka

  Abbiamo spiegato come richiamare schemi di filtraggio e apprendimento con l'Explorer e collegarli insieme all'interfaccia Knowledge Flow. Per andare oltre, è necessario imparare qualcosa su come Weka è messo insieme. Informazioni dettagliate e aggiornate possono essere trovate nella documentazione in linea inclusa nella distribuzione. Questo è più tecnico delle descrizioni degli schemi di apprendimento e filtraggio forniti dal pulsante Altro nell'editor degli oggetti di Explorer e Knowledge Flow. Viene generato direttamente da commenti nel codice sorgente utilizzando l'utilità Javadoc di Sun. Per capire la sua struttura, è necessario sapere come sono organizzati i programmi Java.
   Classes, instances, and packages

  Ogni programma Java è implementato come classe. Nella programmazione object-oriented, una classe è una raccolta di variabili insieme ad alcuni metodi che operano su di essi. Insieme definiscono il comportamento di un oggetto appartenente alla classe. Un oggetto è semplicemente un'istanza della classe che ha valori assegnati a tutte le variabili della classe. In Java, un oggetto viene chiamato anche un'istanza della classe. Purtroppo, questo è in conflitto con la terminologia utilizzata in questo libro, dove le classi di termini e l'istanza appaiono nel contesto piuttosto diverso di apprendimento macchina. Da ora in poi, dovrai dedurre il significato previsto di questi termini dal loro contesto. Questo non è difficile e talvolta useremo l'oggetto parola anziché l'istanza di Java per rendere le cose chiare.

In Weka, l'implementazione di un particolare algoritmo di apprendimento è incapsulata in una classe. Ad esempio, la classe J48 descritta precedentemente costruisce un albero di decisione C4.5. Ogni volta che la macchina virtuale Java esegue J48, crea un'istanza di questa classe assegnando la memoria per la creazione e la memorizzazione di un classificatore di alberi decisionali. L'algoritmo, il classificatore che costruisce e una procedura per la pubblicazione del classificatore sono tutti parte di quella istanza della classe J48.

   I programmi più grandi sono di solito suddivisi in più di una classe. La classe J48, per esempio, non contiene in realtà alcun codice per la creazione di un albero decisionale. Esso include riferimenti a istanze di altre classi che fanno la maggior parte del lavoro. Quando ci sono molte classi, come in Weka, diventano difficili da comprendere e navigare. Java consente di organizzare classi in pacchetti. Un pacchetto è solo una directory che contiene una raccolta di classi correlate: ad esempio, il pacchetto di alberi menzionato in precedenza contiene le classi che implementano gli alberi decisionali. I pacchetti sono organizzati in una gerarchia che corrisponde alla gerarchia di directory: gli alberi sono un sottomarino del pacchetto classificatori, che è di per sé un sotto-pacchetto del pacchetto weka globale.

Quando consultate la documentazione online generata da Javadoc dal tuo browser Web, la prima cosa che vedi è un elenco alfabetico di tutti i pacchetti in Weka, come mostrato nella Figura 13.1 (a). Qui introduciamo alcuni di loro in ordine di importanza.
   The weka.core package

  Il pacchetto di base è centrale per il sistema Weka e le sue classi sono accessibili da quasi tutte le altre classi. È possibile determinare ciò che sono facendo clic sul collegamento ipertestuale weka.core, che richiama la pagina Web mostrata in Figura 13.1 (b).

  La pagina Web della Figura 13.1 (b) è divisa in due parti: il riepilogo dell'interfaccia e il riepilogo di classe. Quest'ultimo è un elenco delle classi contenute all'interno del pacchetto e il primo elenca le interfacce che fornisce. Un'interfaccia è simile a una classe, l'unica differenza è che in realtà non faccia nulla da solo: è solo un elenco di metodi senza implementazioni reali. Altre classi possono dichiarare di "implementare" un'interfaccia particolare e di fornire codice per i suoi metodi. Ad esempio, l'interfaccia OptionHandler definisce i metodi che vengono implementati da tutte le classi che possono elaborare opzioni di riga di comando, incluse tutte le classificatrici.

  Le classi chiave del pacchetto di base sono attributo, istanza e istanze. Un oggetto di classe Attributo rappresenta un attributo. Esso contiene il nome dell'attributo, il suo tipo e, nel caso di un attributo nominale o di stringa, i suoi possibili valori. Un oggetto di istanza di classe contiene i valori di attributo di un'istanza particolare; E un oggetto delle istanze di classe contiene un insieme ordinato di istanze, in altre parole un set di dati. Puoi imparare di più su queste classi cliccando sui loro collegamenti ipertestuali; Torniamo a loro nel capitolo 14 quando ti mostriamo come invocare schemi di apprendimento macchina da altri codice Java. Tuttavia, è possibile utilizzare Weka dalla riga di comando senza conoscere i dettagli.

  Facendo clic sul collegamento ipertestuale Panoramica nell'angolo in alto a sinistra di una qualsiasi pagina di documentazione ti restituisce l'elenco di tutti i pacchetti in Weka mostrati nella Figura 13.1 (a).
   The weka.classifiers package

  Il pacchetto classificatori contiene le implementazioni della maggior parte degli algoritmi di classificazione e di previsione numerica descritti in questo libro. (La previsione numerica è inclusa nei classificatori: viene interpretata come predizione di una classe continua.) La classe più importante di questo pacchetto è il classificatore, che definisce la struttura generale di qualsiasi schema di classificazione o di previsione numerica. Il classificatore contiene tre metodi, buildClassifier (), classifyInstance () e distributionForInstance (). Nella terminologia della programmazione object-oriented, gli algoritmi di apprendimento sono rappresentati da sottoclassi del classificatore e quindi ereditano automaticamente questi tre metodi. Ogni schema le ridefinisce in base a come costruisce un classificatore e come classifica le istanze. Questo fornisce un'interfaccia uniforme per la costruzione e l'utilizzo di classificatori da altri codici Java. Quindi, ad esempio, lo stesso modulo di valutazione può essere utilizzato per valutare le prestazioni di qualsiasi classificatore in Weka.
   Per vedere un esempio, fare clic su weka.classifiers.trees e quindi su DecisionStump, che è una classe per creare un semplice albero di decisione binario di un livello (con un ramo extra per i valori mancanti). La sua pagina di documentazione, mostrata in Figura 13.2, mostra il nome completo di questa classe, weka.classifiers.trees.DecisionStump, vicino alla parte superiore. Devi usare questo nome piuttosto lungo ogniqualvolta crei un blocco di decisione dalla riga di comando. Il nome della classe è collocato in una piccola struttura ad albero che mostra la parte rilevante della gerarchia di classi. Come potete vedere, DecisionStump è una sottoclasse di weka.classifiers.Classifier, che è di per sé una sottoclasse di java.lang.Object. La classe Object è quella più generale in Java: tutte le classi sono automaticamente sottoclassi.

  Dopo alcune informazioni generiche sulla classe - breve la documentazione, la sua versione e l'autore - la Figura 13.2 fornisce un indice dei costruttori e dei metodi di questa classe. Un costruttore è un tipo speciale di metodo che si chiama ogni volta che viene creato un oggetto di questa classe, normalmente inizializzando le variabili che definiscono collettivamente il suo stato. L'indice dei metodi elenca il nome di ciascuno, il tipo di parametri che richiede e una breve descrizione della sua funzionalità. Sotto questi indici, la pagina Web fornisce maggiori dettagli sui costruttori e sui metodi. Ritorneremo a questi dettagli più tardi.

   Come si può vedere, DecisionStump sovrascrive il metodo distributionForInstance () da Classifier: l'implementazione predefinita di classifyInstance () in Classifier utilizza quindi questo metodo per produrre le sue classificazioni. Inoltre, contiene i metodi toString (), toSource () e main (). Il primo restituisce una descrizione testuale del classificatore, usata ogni volta che viene stampata sullo schermo. Il secondo viene utilizzato per ottenere una rappresentazione del codice sorgente del classificatore esperto. Il terzo viene chiamato quando si chiede una decisione di stump dalla riga di comando, in altre parole, ogni volta che si immette un comando che inizia con


  java weka.classifiers.trees.DecisionStump


  La presenza di un metodo main () in una classe indica che può essere eseguito dalla riga di comando e che tutti i metodi di apprendimento e gli algoritmi di filtro lo implementano.
     Other packages

  Vanno menzionati altri pacchetti elencati nella Figura 13.1 (a): weka.associations, weka.clusterers, weka.estimators, weka.filters e weka.attributeSelection. Il pacchetto weka.associations contiene gli allievi delle regole di associazione. Questi sono stati collocati in un pacchetto separato poiché le regole di associazione sono fondamentalmente diverse dai classificatori. Il pacchetto weka.clusterers contiene metodi per l'apprendimento non supervisionato. Il pacchetto weka.estimators contiene sottoclassi di una classe generica di stimatore, che calcola diversi tipi di distribuzione di probabilità. Queste sottoclasse vengono utilizzate dall'algoritmo Naïve Bayes (tra gli altri).
   Nel pacchetto weka.filters, la classe Filter definisce la struttura generale delle classi contenenti algoritmi di filtro, tutti implementati come sottoclassi del filtro. Come i classificatori, i filtri possono essere usati dalla riga di comando: vedremo quanto poco. Il pacchetto weka.attributeSelection contiene diverse classi per la selezione degli attributi. Questi vengono utilizzati dall'attributo AttributeSelectionFilter in weka.filters.supervised.attribute, ma possono anche essere invocati separatamente.
   Javadoc indices

  Come accennato in precedenza, tutte le classi sono automaticamente sottoclassi di Object. Per esaminare l'albero che corrisponde alla gerarchia di classi di Weka, selezionare il collegamento Panoramica dalla parte superiore di qualsiasi pagina della documentazione in linea. Fare clic su Albero per visualizzare la panoramica come un albero che mostra quali classi sono sottoclassi o super-classi di una classe particolare, ad esempio, quali classi ereditano da Classifier. La documentazione in linea contiene un indice di tutte le variabili pubbliche accessibili (i campi chiamati) ei metodi in Weka, in altre parole, tutti i campi ei metodi che è possibile accedere dal proprio codice Java. Per visualizzarlo, fare clic su Panoramica e quindi Indice.
  Supponiamo che si desideri controllare quali classificatori e filtri Weka sono in grado di operare in modo incrementale. La ricerca della parola incrementale nell'indice avrebbe portato alla parola chiave UpdateableClassifier. Infatti, questa è un'interfaccia Java; Le interfacce vengono elencate dopo le classi nell'albero di riepilogo. Stai cercando tutte le classi che implementano questa interfaccia. Facendo clic su una eventuale presenza nella documentazione, viene visualizzata una pagina che descrive l'interfaccia e elenca i classificatori che lo implementano. Trovare i filtri è un po 'più complicato se non conosci la parola chiave StreamableFilter, che è il nome dell'interfaccia che effettua i dati attraverso un filtro: ancora una volta, la sua pagina elenca i filtri che lo implementano. Avresti inciampato in quella parola chiave se sapevi un esempio di un filtro che potrebbe funzionare in modo incrementale.
   Command-line options

  Nell'esempio precedente, l'opzione -t è stata utilizzata nella riga di comando per comunicare il nome del file di addestramento all'algoritmo di apprendimento. Ci sono molte altre opzioni che possono essere utilizzate con qualsiasi schema di apprendimento e anche schemi specifici che si applicano solo a schemi particolari. Se si richiama uno schema senza alcuna opzione di riga di comando, esso visualizza le opzioni applicabili: prima le opzioni generali, quindi quelle specifiche al programma. Nell'interfaccia della riga di comando digitare:


  java weka.classifiers.trees.J48


Vedrai un elenco delle opzioni comuni a tutti i piani di apprendimento, mostrati nella Tabella 13.1, seguiti da quelli che si applicano solo a J48, mostrati nella Tabella 13.2. Spiegheremo le opzioni generiche e poi rivedremo brevemente gli schemi specifici.
  Generic options

  Le opzioni nella tabella 13.1 determinano quali dati vengono utilizzati per la formazione e il test, come viene valutato il classificatore e quali tipi di statistiche vengono visualizzate. Ad esempio, l'opzione -T viene utilizzata per fornire il nome del file di prova durante la valutazione di uno schema di apprendimento su un set di test indipendente. Per impostazione predefinita, la classe è l'ultimo attributo in un file ARFF, ma è possibile dichiarare un altro come classe utilizzando -c seguito dalla posizione dell'attributo desiderato, 1 per il primo, 2 per il secondo e così via. Quando viene eseguita la convalida incrociata (il valore predefinito se non viene fornito un file di prova), i dati vengono prima mescolati in modo casuale. Per ripetere più volte la convalida incrociata, ogni volta che riorganizza i dati in modo diverso, impostare il numero di casuale numero con -s (valore predefinito 1). Con un grande set di dati è possibile ridurre il numero di pieghe per la convalida incrociata dal valore predefinito di 10 usando -x.  Nell'Esplorer, viene valutata la valutazione sensibile ai costi come descritto nella sezione 10.1. Per ottenere lo stesso effetto dalla riga di comando, utilizzare l'opzione -m per fornire il nome di un file contenente la matrice di costo. Ecco una matrice dei costi per i dati meteorologici:

  ....

 La prima riga fornisce il numero di righe e colonne, cioè il numero di valori di classe. Poi viene la matrice delle sanzioni. I commenti introdotti da% possono essere aggiunti alla fine di qualsiasi riga.
È inoltre possibile salvare e caricare i modelli. Se si fornisce il nome di un file di output utilizzando -d, Weka salva il classificatore generato dai dati di allenamento.

  Per valutare lo stesso classificatore su un nuovo gruppo di dati di prova, lo riprenderai utilizzando -l invece di ricostruirlo. Se il classificatore può essere aggiornato in modo incrementale, è possibile fornire sia un file di formazione che un file di input e Weka caricherà il classificatore e aggiornarlo con le istruzioni di formazione specificate. Se si desidera solo valutare le prestazioni di un programma di apprendimento, utilizzare -o per sopprimere l'output del modello. Utilizzare -i per visualizzare le misure di prestazione di precisione, richiamo e misure F (sezione 5.7). Utilizzare -k per calcolare le misure informative teoriche dalle probabilità derivate da uno schema di apprendimento (Sezione 5.6).
  Gli utenti di Weka spesso vogliono sapere quali classi valgono lo schema di apprendimento effettivamente prevede per ogni istanza di prova. L'opzione -p consente di stampare ogni numero di istanza del test, la sua classe, la fiducia della predizione dello schema e il valore della classe previsto. Essa inoltre emette valori di attributo per ogni istanza e deve essere seguita da una specifica dell'intervallo (ad esempio, 1-2) -use 0 se non si desidera alcun valore di attributo. È anche possibile emettere la distribuzione dei margini cumulativi per i dati di addestramento, che mostra come la distribuzione della misura di margine (Sezione 7.5, pag. 324) cambia con il numero di incrementi di iterazioni. Infine, è possibile emettere la rappresentazione di origine del classificatore e una rappresentazione grafica se il classificatore può produrre uno.
  Scheme-specific options

   La tabella 13.2 mostra le opzioni specifiche di J4.8. È possibile forzare l'algoritmo per utilizzare l'albero non trattato, anziché il potato. È possibile sopprimere il sollevamento del sottosuolo, aumentando l'efficienza. È possibile impostare la soglia di fiducia per la potatura e il numero minimo di istanze consentite a qualsiasi foglio - entrambi i parametri sono descritti nel capitolo 6.1 (pagina 199). Oltre alla procedura di potatura standard C4.5, è possibile eseguire potature a errore ridotto (sezione 6.2, pagine 202-203). L'opzione -N regola la dimensione del set di holdout: il set di dati è suddiviso in maniera uguale in quel numero di parti e l'ultimo viene tirato fuori (valore predefinito 3). Puoi lisciare le stime di probabilità utilizzando la tecnica Laplace, impostare il numero di casuale numero per mescolare i dati durante la selezione di un set di potatura e memorizzare le informazioni di istanza per la visualizzazione futura. Infine, per costruire un albero binario invece di uno con rami multipli per gli attributi nominali, utilizza -B.
     Embedded Machine Learning

  Quando si invoca schemi di apprendimento dalle interfacce utente grafiche o dalla riga di comando, non c'è bisogno di sapere nulla sulla programmazione in Java. In questa sezione mostriamo come accedere a questi algoritmi dal proprio codice. In tal modo, i vantaggi di utilizzare un linguaggio di programmazione orientato agli oggetti diventano chiari. D'ora in poi, supponiamo che tu abbia almeno alcune conoscenze rudimentali di Java. Nella maggior parte delle applicazioni pratiche di data mining, il componente di apprendimento è parte integrante di un ambiente software molto più ampio. Se l'ambiente è scritto in Java, è possibile utilizzare Weka per risolvere il problema dell'apprendimento senza scrivere alcun codice di apprendimento macchina da soli.
   A simple data mining application

  Presentiamo un'applicazione di data mining semplice per l'apprendimento di un modello che classifica i file di testo in due categorie, colpi e miss. L'applicazione funziona per documenti arbitrari: li facciamo riferimento come messaggi. L'implementazione utilizza il filtro StringToWordVector menzionato nella sezione 10.3 (pagina 399) per convertire i messaggi in vettori attributi nel modo descritto nella sezione 7.3. Supponiamo che il programma sia chiamato ogni volta che un nuovo file deve essere elaborato. Se l'utente Weka fornisce un'etichetta di classe per il file, il sistema lo usa per la formazione; Se non lo classifica. Il classificatore dell'organismo di decisione J48 viene utilizzato per eseguire il lavoro.
  Going through the code

  La Figura 14.1 mostra il codice sorgente del programma applicativo, implementato in una classe chiamata MessageClassifier. Gli argomenti della riga di comando che il metodo main () accetta sono il nome di un file di testo (dato da -m), il nome di un file che detiene un oggetto della classe MessageClassifier (-t) e, eventualmente, la classificazione della Messaggio nel file (-c). Se l'utente fornisce una classificazione, il messaggio verrà convertito in un esempio per la formazione; Se no, l'oggetto Message-Classifier verrà utilizzato per classificarlo come hit o miss.
  main()

  Il metodo main () legge il messaggio in un Java StringBuffer e verifica se l'utente ha fornito una classificazione per esso. Quindi legge un oggetto Message-Classifier dal file dato da -t e crea un nuovo oggetto della classe MessageClassifier se questo file non esiste. In entrambi i casi l'oggetto risultante viene chiamato messageCl. Dopo aver verificato le opzioni di riga di comando illegali, il programma chiama il metodo updateData () per aggiornare i dati di allenamento memorizzati in messageCl se è stata fornita una classificazione; Altrimenti, chiama classifyMessage () per classificarla. Infine, l'oggetto messageCl viene salvato nel file, perché potrebbe essere cambiato. Nelle sezioni seguenti, descriviamo innanzitutto come un nuovo MessageClassifier oggetto viene creato dal costruttore MessageClassifier () e spiega quindi come funzionano i due metodi updateData () e classifyMessage ().
  MessageClassifier()

Figure 14.1 Source code for the message classifier.


 Ogni volta che viene creato un nuovo MessageClassifier, gli oggetti per il controllo del filtro e del classificatore vengono generati automaticamente. L'unica parte non intima del processo è la creazione di un set di dati, che viene fatto dal costruttore MessageClassifier (). In primo luogo il nome del set di dati viene memorizzato come una stringa. Allora un oggetto attributo viene creato per ogni attributo, uno per contenere la stringa corrispondente a un messaggio di testo e l'altro per la sua classe. Questi oggetti vengono memorizzati in una matrice dinamica del tipo FastVector. (FastVector è la propria implementazione della classe Java Vector standard e viene utilizzata in tutta la Weka per motivi storici.)
   Gli attributi vengono creati richiamando uno dei costruttori nell'attributo di classe. Questa classe ha un costruttore che prende un parametro - il nome dell'attributo - e crea un attributo numerico. Tuttavia, il costruttore che utilizziamo qui richiede due parametri: il nome dell'attributo e un riferimento a un FastVector. Se questo riferimento è nullo, come nella prima applicazione di questo costruttore nel nostro programma, Weka crea un attributo di stringa di tipo. Altrimenti, viene creato un attributo nominale. In questo caso si suppone che il FastVector detiene i valori degli attributi come stringhe. Questo è il modo in cui creiamo un attributo di classe con due valori colpiti e mancati: passando il nome (classe) e il valore dei suoi attributi - memorizzati in FastVector - in Attributo ().
   Per creare un set di dati da questa informazione di attributo, MessageClassifier () deve creare un oggetto delle istanze di classe dal pacchetto di base. Il costruttore di istanze usate da MessageClassifier () prende tre argomenti: il nome del set di dati, un FastVector che contiene gli attributi e un numero intero che indica la capacità iniziale del set di dati. Abbiamo impostato la capacità iniziale su 100; Viene espanso automaticamente se vengono aggiunti più istanze. Dopo la costruzione del set di dati, Message-Classifier () imposta l'indice dell'attributo di classe come l'indice dell'ultimo attributo.
  updateData()

  Ora che sai come creare un set di dati vuoto, consideri come l'oggetto MessageClassifier incorpora effettivamente un nuovo messaggio di allenamento. Il metodo updateData () effettua questo lavoro. In primo luogo converte il messaggio dato in un'istanza di formazione chiamando makeInstance (), che inizia creando un oggetto di istanza di classe che corrisponde a un'istanza con due attributi. Il costruttore dell'oggetto Instance imposta tutti i valori dell'istanza da mancare e il suo peso a 1. Il passaggio successivo di makeInstance () è quello di impostare il valore dell'attributo stringa che detiene il testo del messaggio. Questo viene fatto applicando il metodo setValue () dell'oggetto Instance, fornendolo con l'attributo il cui valore deve essere modificato e un secondo parametro che corrisponde all'indice del nuovo valore nella definizione dell'attributo stringa. Questo indice viene restituito dal metodo addStringValue (), che aggiunge il testo del messaggio come un nuovo valore all'attributo stringa e restituisce la posizione di questo nuovo valore nella definizione dell'attributo stringa.

  Internamente, un istanza memorizza tutti i valori dell'attributo come numeri a virgola mobile a doppia precisione indipendentemente dal tipo di attributo corrispondente. Nel caso di attributi nominali e di stringa questo viene fatto memorizzando l'indice del valore attributo corrispondente nella definizione dell'attributo. Ad esempio, il primo valore di un attributo nominale è rappresentato da 0,0, il secondo da 1,0 e così via.
  Lo stesso metodo viene utilizzato per gli attributi di stringa: addStringValue () restituisce l'indice corrispondente al valore aggiunto alla definizione dell'attributo. Una volta impostato il valore dell'attributo stringa, makeInstance () fornisce l'accesso di istanza appena creato alle informazioni sugli attributi dei dati, passandolo un riferimento al set di dati. In Weka, un oggetto Instance non memorizza esplicitamente il tipo di ogni attributo; Invece, memorizza un riferimento a un set di dati con le corrispondenti informazioni sugli attributi.
  Tornando a updateData (), una volta che la nuova istanza è stata restituita da makeInstance (), il valore di classe viene impostato e viene aggiunto ai dati di addestramento. Iniziamo anche m_UpToDate, una bandiera che indica che i dati formativi sono cambiati e che il modello predittivo non è quindi aggiornato.
  classifyMessage()

  Ora esaminiamo come MessageClassifier elabora un messaggio la cui etichetta di classe è sconosciuta. Il metodo classifyMessage () controlla prima se sia stato creato un classificatore determinando se sono disponibili istanze di formazione. Verifica quindi se il classificatore è aggiornato. Se no (perché i dati di formazione sono cambiati) deve essere ricostruito. Tuttavia, prima di procedere, i dati devono essere convertiti in un formato appropriato per l'apprendimento utilizzando il filtro StringToWordVector.
  Innanzitutto, indichiamo al filtro il formato dei dati di ingresso passando un riferimento al set di dati di input utilizzando setInputFormat (). Ogni volta che questo metodo viene chiamato, il filtro viene inizializzato, cioè tutte le sue impostazioni interne vengono reimpostate. Nella fase successiva, i dati vengono trasformati da useFilter (). Questo metodo generico della classe Filtro applica un filtro a un set di dati. In questo caso, poiché StringToWordVector è stato appena inizializzato, calcola un dizionario dal dataset di addestramento e lo usa per formare vettori di parole. Dopo il ritorno da useFilter (), tutte le impostazioni interne del filtro vengono fissate finché non viene inizializzata da un'altra chiamata di inputFormat (). Ciò consente di filtrare un'istanza di prova senza aggiornare le impostazioni interne del filtro (in questo caso il dizionario).
   Una volta che i dati sono stati filtrati, il programma ricostruisce il classificatore - nel nostro caso un albero di decisione J4.8 - passando i dati di addestramento al suo metodo buildClassifier () e imposta m_UpToDate su true. È una convenzione importante in Weka che il metodo buildClassifier () inizializza completamente le impostazioni interne del modello prima di generare un nuovo classificatore. Quindi non abbiamo bisogno di costruire un nuovo oggetto J48 prima di chiamare buildClassifier ().

  Assicurando che il modello memorizzato in m_Classifier sia attuale, continuiamo a classificare il messaggio. Prima che makeInstance () sia chiamato a creare un oggetto istanza da esso, viene creato un nuovo oggetto Instances per contenere la nuova istanza e passato come argomento a makeInstance (). Questo viene fatto in modo che makeInstance () non aggiunga il testo del messaggio alla definizione dell'attributo stringa in m_Data. Altrimenti, la dimensione dell'oggetto m_Data crescerebbe ogni volta che un nuovo messaggio è stato classificato, cosa che non è chiaramente auspicabile: dovrebbe crescere solo quando vengono aggiunti istanze di addestramento. Di conseguenza, un oggetto temporaneo Instances viene creato e scartato una volta che l'istanza è stata elaborata. Questo oggetto viene ottenuto utilizzando il metodo stringFreeStructure (), che restituisce una copia di m_Data con un attributo di stringa vuota. Solo allora è makeInstance () chiamato per creare la nuova istanza.
   L'istanza di prova deve essere elaborata anche dal filtro StringToWordVector prima di essere classificata. Questo è facile: il metodo input () inserisce l'istanza nell'oggetto filtro e l'istanza trasformata viene ottenuta chiamando output (). Quindi una previsione viene prodotta passando l'istanza al metodo classifyInstance () del classificatore. Come si può vedere, la previsione è codificata come un doppio valore. Questo permette al modulo di valutazione Weka di trattare in modo analogo i modelli per la previsione categorica e numerica. Nel caso di predizione categoriale, come in questo esempio, la doppia variabile detiene l'indice del valore della classe previsto. Per emettere la stringa corrispondente a questo valore di classe, il programma chiama il metodo value ()  dell'attributo di classe del set di dati.

  C'è almeno un modo per migliorare la nostra implementazione. Il filtro e il filtro StringToWordVector potrebbero essere combinati utilizzando il metalearner FilteredClassifier descritto nella sezione 10.3 (pagina 401). Questo classificatore potrebbe quindi essere in grado di gestire direttamente gli attributi di stringa, senza chiamare esplicitamente il filtro per trasformare i dati. Non abbiamo fatto questo perché abbiamo voluto dimostrare come i filtri possono essere utilizzati in modo programmato.
      Writing New Learning Schemes

  Supponi che sia necessario implementare un algoritmo di apprendimento speciale che non sia incluso in Weka. Oppure si suppone di essere impegnato in ricerca di apprendimento macchina e desideri indagare su un nuovo schema di apprendimento. Oppure si desidera solo imparare di più sul funzionamento interno di un algoritmo di induzione realmente programmandola da soli. Questa sezione utilizza un semplice esempio per mostrare come utilizzare pienamente la gerarchia di classi di Weka durante la scrittura di classificatori.
   Weka comprende i sistemi di apprendimento elementare elencati nella tabella 15.1, principalmente per scopi didattici. Nessuno esegue opzioni specifiche di riga di comando specifiche del sistema. Sono tutti utili per comprendere i funzionamenti interni di un classificatore. Ad esempio, descriviamo il schema weka.classifiers.trees.Id3, che implementa l'ID3 albero di decisione decisionale di Sezione 4.3.
   An example classifier

  La Figura 15.1 fornisce il codice sorgente di weka.classifiers.trees.Id3, che, come si può vedere dal codice, estende la classe Classifier. Ogni classificatore in Weka lo fa, se prevede una classe nominale o una numerica.
Il primo metodo in weka.classifiers.trees.Id3 è globalInfo (): lo menzionamo qui prima di passare alle parti più interessanti. Viene semplicemente restituito una stringa visualizzata nelle interfacce grafiche di Weka quando viene selezionato questo schema.
  buildClassifier()

  Il metodo buildClassifier () costruisce un classificatore da un set di dati di formazione. In questo caso controlla prima i dati per una classe nonnominale, il valore attributo mancante o qualsiasi attributo non nominale, perché l'algoritmo ID3 non è in grado di gestire questi. Quindi fa una copia del set di formazione (per evitare di cambiare i dati originali) e chiama un metodo da weka.core.Instances per eliminare tutte le istanze con valori di classe mancanti, perché queste istanze sono inutili nel processo di formazione. Infine, chiama makeTree (), che effettua effettivamente l'albero decisionale generando ricorsivamente tutti i sottofondi collegati al nodo radice.
     makeTree()

 Figure 15.1 Source code for the ID3 decision tree learner.


   Il primo passo in makeTree () è verificare se il set di dati è vuoto. Se è, una foglia viene creata impostando m_Attribute su null. Il valore di classe m_ClassValue assegnato a questa foglia è impostato a mancare e la probabilità stimata per ciascuna classe di dati in m_Distribution viene inizializzata a 0. Se sono presenti istanze di formazione, makeTree () trova l'attributo che fornisce il maggiore guadagno di informazioni per loro. In primo luogo crea un'enumerazione Java degli attributi del set di dati. Se l'indice dell'attributo di classe è impostato - come sarà per questo set di dati - la classe viene automaticamente esclusa dall'enumerazione.
   All'interno dell'enumerazione, il guadagno di informazioni di ogni attributo viene calcolato da computeInfoGain () e memorizzato in un array. Ritorneremo a questo metodo in seguito. Il metodo index () di weka.core.Attribute restituisce l'indice dell'attributo nel set di dati utilizzato per indicizzare l'array. Una volta completata l'enumerazione, l'attributo con il maggiore guadagno di informazioni viene memorizzato nella variabile di istanza m_Attribute. Il metodo maxIndex () da weka.core.Utils restituisce l'indice del valore più grande in una matrice di interi o doppi. (Se c'è più di un elemento con il valore massimo, viene restituito il primo.) L'indice di questo attributo viene passato al metodo attributo () da weka.core.Instances, che restituisce l'attributo corrispondente.

  Si potrebbe chiedere che cosa accade al campo di matrice corrispondente all'attributo di classe. Non dobbiamo preoccuparci di questo perché Java inizia automaticamente tutti gli elementi in una serie di numeri a zero e il guadagno di informazioni è sempre maggiore o uguale a zero. Se il guadagno massimo di informazioni è zero, make-Tree () crea una foglia. In questo caso m_Attribute è impostato su null e makeTree () calcola sia la distribuzione delle probabilità di classe che la classe con la massima probabilità. (Il metodo di normalizzazione () da weka.core.Utils normalizza una matrice di doppi da somma a uno.)
   Quando crea una foglia con un valore di classe assegnato ad esso, makeTree () memorizza l'attributo di classe in m_ClassAttribute. Questo perché il metodo che emette l'albero decisionale deve accedere a questo per stampare l'etichetta di classe. Se si trova un attributo con il guadagno di informazioni non-zero, makeTree () suddivide il set di dati in base ai valori dell'attributo e costruisce ricorsivamente sottofondi per ciascuno dei nuovi set di dati. Per eseguire la suddivisione si chiama il metodo splitData (). Ciò crea il numero di set di dati vuoti, in quanto esistono valori di attributo, li memorizza in un array (imposta la capacità iniziale di ciascun set di dati al numero di istanze nel dataset originale) e poi si esegue attraverso tutte le istanze nel set di dati originale e le assegna Al nuovo set di dati che corrisponde al valore dell'attributo. Quindi riduce i requisiti di memoria comprimendo gli oggetti Instances. Tornando a makeTree (), l'array risultante di set di dati viene utilizzato per creare sottofondi. Il metodo crea una matrice di oggetti Id3, uno per ciascun valore di attributo e chiama makeTree () su ciascuno di essi passandolo il set di dati corrispondente.
     computeInfoGain()

  Tornando a computeInfoGain (), il guadagno informativo associato ad un attributo e ad un set di dati viene calcolato utilizzando un'applicazione diretta della formula nella sezione 4.3 (pagina 102). In primo luogo, viene calcolata l'entropia del set di dati. Quindi, splitData () viene utilizzato per suddividerlo in sottotitoli e viene chiamato a ciascuno di essi computeEntropy (). Infine, viene restituita la differenza tra l'ex entropia e la somma ponderata di questi ultimi - il guadagno di informazioni. Il metodo computeEntropy () utilizza il metodo log2 () da weka.core.Utils per ottenere il logaritmo (alla base 2) di un numero.
   classifyInstance()

  Dopo aver visto come ID3 costruisce un albero di decisione, ora esaminiamo come utilizzi la struttura ad albero per prevedere valori e probabilità di classe. Ogni classificatore deve implementare il metodo classifyInstance () o il metodo distributionForInstance () o entrambi. La classe superficiale Classifier contiene implementazioni predefinite per entrambi i metodi. L'implementazione predefinita di classifyInstance () chiama distributionForInstance (). Se la classe è nominale, prevede la classe con la massima probabilità o un valore mancante se tutte le probabilità restituite da distributionForInstance () sono zero. Se la classe è numerica, distributionForInstance () deve restituire un array di un singolo elemento che contiene la previsione numerica e questo è ciò che la classe-fyInstance () estrae e restituisce. Al contrario, l'implementazione predefinita di distributionForInstance () avvolge la previsione ottenuta da classifyInstance () in un array di un singolo elemento. Se la classe è nominale, distributionForInstance () assegna una probabilità di una alla classe prevista da classifyInstance () e una probabilità di zero agli altri. Se classifyInstance () restituisce un valore mancante, tutte le probabilità sono impostate su zero. Per dare una sensazione migliore per ciò che questi metodi fanno, la classe weka.classifiers.trees.Id3 le sovrascrive entrambe.

   Prendiamo innanzitutto la classifyInstance (), che prevede un valore di classe per una determinata istanza. Come indicato nella sezione precedente, i valori nominali di classe, come i valori attributi nominali, sono codificati e memorizzati in doppie variabili, rappresentanti l'indice del nome del valore nella dichiarazione degli attributi. Questo viene utilizzato in favore di un approccio più orientato agli oggetti per aumentare la velocità di esecuzione. Nell'implementazione di ID3, classifyInstance () controlla prima se esistono valori mancanti nell'istanza da classificare; Se sì, lancia un'eccezione. Altrimenti, scende l'albero in modo ricorsivo, guidato dai valori dell'attributo dell'istanza, finché non viene raggiunta una foglia. Quindi restituisce il valore di classe m_ClassValue memorizzato alla foglia. Si noti che questo potrebbe essere un valore mancante, nel qual caso l'istanza è lasciata non classificata. Il metodo distributionForInstance () funziona esattamente nello stesso modo, restituendo la distribuzione di probabilità memorizzata in m_Distribution.
  La maggior parte dei modelli di apprendimento macchina, e in particolare gli alberi decisionali, servono come una spiegazione più o meno comprensibile della struttura trovata nei dati. Di conseguenza, ognuno dei classificatori di Weka, come molti altri oggetti Java, implementa un metodo toString () che produce una rappresentazione testuale di se stessa in forma di una variabile String. Il metodo toString () di ID3 emette un'albero di decisione in modo approssimativamente lo stesso formato di J4.8 (Figura 10.5). Stampa in modo ricorsivo la struttura ad albero in una variabile String accedendo alle informazioni sugli attributi memorizzate nei nodi. Per ottenere il nome e i valori di ciascun attributo, utilizza i metodi name () e value () da weka.core.Attribute. Le foglie vuote senza un valore di classe sono indicate dalla stringa null.
     main()

  L'unico metodo in weka.classifiers.trees.Id3 che non è stato descritto è main (), che viene chiamato ogni volta che la classe viene eseguita dalla riga di comando. Come potete vedere, è semplice: in pratica dice alla classe di valutazione di Weka di valutare Id3 con le opzioni di riga di comando specificate e di stampare la stringa risultante. L'espressione unica che fa questo è racchiusa in un'istruzione di prova che cattura le diverse eccezioni che possono essere state lanciate dalle routine di Weka o da altri metodi Java.

 Il metodo di valutazione () in weka.classifiers.Evaluation interpreta le opzioni di riga di comando indipendenti dal sistema descritto nella sezione 13.3 e agisce in modo appropriato. Ad esempio, prende l'opzione -t, che fornisce il nome del file di addestramento e carica il set di dati corrispondente. Se non esiste un file di prova, esegue una convalida incrociata creando un oggetto classificatore e ripetutamente chiamando buildClassifier () e classificaInstance () o distributionForInstance () su diversi sottotitoli dei dati formativi. A meno che l'utente non sopprime l'output del modello impostando l'opzione della riga di comando corrispondente, anche il metodo toString () invia il modello creato dal dataset completo di formazione.

  Cosa succede se lo schema deve interpretare un'opzione specifica, ad esempio un parametro di potatura? Questo viene eseguito utilizzando l'interfaccia OptionHandler in weka.core. Un classificatore che implementa questa interfaccia contiene tre metodi, listOptions (), setOptions () e getOptions (), che possono essere utilizzati per elencare tutte le opzioni specifiche del sistema del classificatore, per impostarne alcune e per ottenere le opzioni che sono Attualmente impostato. Il metodo di valutazione () in Evaluation chiama automaticamente questi metodi se il classificatore implementa l'interfaccia OptionHandler. Una volta elaborate le opzioni indipendenti dal sistema, chiama setOptions () per elaborare le opzioni rimanenti prima di utilizzare buildClassifier () per generare un nuovo classificatore. Quando esegue il classificatore, utilizza getOptions () per visualizzare un elenco delle opzioni attualmente impostate. Per un semplice esempio di come implementare questi metodi, guarda il codice sorgente per weka.classifiers.rules.OneR.
   OptionHandler consente di impostare le opzioni dalla riga di comando. Per impostarli dall'interno delle interfacce utente grafiche, Weka utilizza il framework Java Beans. Tutto ciò che è richiesto è impostare ... () e ottenere ... () metodi per ogni parametro utilizzato dalla classe. Ad esempio, i metodi setPruningParameter () e getPruningParameter () sarebbero necessari per un parametro di potatura. Dovrebbe esserci anche un metodo di pruningParameterTipText () che restituisce una descrizione del parametro per l'interfaccia grafica utente. Di nuovo, vedere weka.classifiers.rules.OneR per un esempio.

   Alcuni classificatori possono essere aggiornati in modo incrementale in quanto arrivano nuove istanze di formazione; Non devono elaborare tutti i dati in un unico batch. In Weka, i classificatori incrementali implementano l'interfaccia UpdateableClassifier in weka.classifiers. Questa interfaccia dichiara un solo metodo, ovvero updateClassifier (), che esegue un'istanza di formazione singola come argomento. Per un esempio di come utilizzare questa interfaccia, guarda il codice sorgente per weka.classifiers.lazy.IBk. Se un classificatore è in grado di utilizzare pesi di istanza, dovrebbe implementare l'interfaccia WeightedInstancesHandler () da weka.core. Poi altri algoritmi, come quelli per il potenziamento, possono utilizzare questa proprietà. In weka.core sono molte altre interfacce utili per i classificatori - ad esempio, interfacce per classificatori che sono randomizzabili, riepilogabili, disegnabili e graficabili. Per ulteriori informazioni su queste ed altre interfacce, consulta la Javadoc per le classi in weka.core.
    Conventions for implementing classifiers

 Ci sono alcune convenzioni che dovete obbedire quando implementate classificatori in Weka. Se non lo fai, le cose andranno male. Ad esempio, il modulo di valutazione di Weka potrebbe non calcolare correttamente le statistiche del classificatore quando la valuta.
   La prima convenzione è già stata menzionata: ogni volta che viene chiamato un metodo buildClassifier () di classificatore, deve reimpostare il modello. La classe CheckClassifier esegue test per assicurarsi che questo sia il caso. Quando buildClassifier () viene richiamato su un set di dati, è sempre necessario ottenere lo stesso risultato, indipendentemente dal numero di volte che il classificatore è stato precedentemente applicato agli stessi o altri set di dati. Tuttavia, buildClassifier () non deve reimpostare variabili di istanza che corrispondono alle opzioni systempecific, poiché queste impostazioni devono persistere con più chiamate di buildClassifier (). Inoltre, chiamare buildClassifier () non deve mai cambiare i dati di input. Sono state anche citate altre due convenzioni. Uno è che quando un classificatore non può fare una previsione, il suo metodo classifyInstance () deve restituire l'istanza.missingValue () e il suo metodo di distributionForInstance () deve restituire probabilità di zero per tutte le classi. L'implementazione di ID3 nella Figura 15.1 fa questo. Un'altra convenzione è che con i classificatori per la previsione numerica, class-fyInstance () restituisce il valore numerico che il classificatore prevede. Alcuni classificatori, tuttavia, sono in grado di prevedere classi nominali e le loro probabilità di classe, nonché i valori di classe numerica, weka.classifiers.lazy.IBk è un esempio. Questi implementano il metodo istributionForInstance () e se la classe è numerica restituisce una matrice di dimensione 1 il cui unico elemento contiene il valore numerico previsto.

   Un'altra convenzione - non assolutamente essenziale ma utile comunque - è che ogni classificatore implementa un metodo toString () che emette una descrizione testuale di se stessa.