| Oratore |
Trascrizione |
| Lucas |
Ok, grazie a tutti per essere venuti ad ascoltare il mio intervento. Mi chiamo Lucas Beverlin e sono uno statistico di Intel. |
| |
E oggi parlerò dell'uso di JMP per confrontare modelli provenienti da diversi ambienti. |
| |
Bene, quindi attualmente JMP 15 Pro è l'ultima e migliore versione di JMP e se vuoi adattare il modello, hanno diversi strumenti per farlo. |
| |
C'è la piattaforma per il modello di adattamento. C'è la piattaforma neurale sulla piattaforma di partizione delle reti neurali. Se vuoi alberi di classificazione e regressione. La piattaforma non lineare per la modellazione non lineare e ce ne sono molte altre. |
| |
E quindi entro JMP 15 penso che sia uscito nel 12 o 13, ma questa piattaforma di confronto dei modelli è uno strumento molto utile che puoi usare per confrontare |
| |
Il modello si adatta a diverse piattaforme all'interno di JMP. Quindi, se hai un albero e una rete neurale e non sei sicuro di quale sia migliore, puoi passare da una all'altra. Ma ora, con questo, |
| |
Hai tutto sulla stessa schermata. È molto facile e veloce capire se questo è meglio di quello, e così via. |
| |
Detto questo, JMP può gestire molte cose, ma purtroppo non tutto. Quindi, ecco alcuni esempi di cose che non possono essere gestite. Ad esempio, |
| |
quelli che fanno molto apprendimento automatico e intelligenza artificiale potrebbero adattarsi a qualcosa come un codificatore automatico o una rete neurale convoluzionale che generalmente richiede molte funzioni di attivazione o sì, molti nodi di livelli nascosti, |
| |
altre funzioni di attivazione rispetto a quelle offerte da JMP, quindi JMP non sarà in grado di fare molte di queste cose al suo interno. |
| |
Un altro è quello chiamato regressione di ricerca di proiezione. Un altro è quello chiamato spline di regressione adattiva multivariata. Quindi ci sono alcune cose che purtroppo JMP non può fare. |
| |
R, Python e MATLAB. |
| |
Ce ne sono molti altri là fuori, |
| |
Ma mi concentrerò su questi tre. Detto questo, le idee che discuterò qui, dovrete adattarle a C++, Java, Rust o qualsiasi altro linguaggio. |
| |
mi viene in mente, dovresti riuscire a usarne molti. |
| |
Quindi, come ho detto, possiamo usare la piattaforma di confronto modelli anche per confrontare altri software. Di cosa avrai bisogno? |
| |
Quindi le due cose più importanti di cui avrai bisogno sono le previsioni del modello ottenute dal software che utilizzerai per adattare il modello. |
| |
In genere, quando eseguiamo l'adattamento del modello, in particolare con modelli più grandi, è possibile suddividere i dati in set di addestramento, convalida e/o test. |
| |
Avrai bisogno di qualcosa che dica a tutto il software qual è la fase di addestramento, qual è la fase di convalida e qual è la fase di test, perché vorrai che siano coerenti quando confronti gli adattamenti. |
| |
Bene, il motivo principale per cui ho scelto di concentrarmi su R, Python e MATLAB per questa presentazione è che, a quanto pare, JMP e il linguaggio di scripting possono effettivamente creare le proprie sessioni di R ed eseguire il codice da esse. |
| |
Quindi questa immagine qui mostra molto rapidamente come adattare un modello di regressione lineare a un output |
| |
Al set di dati sul mercato immobiliare di Boston. Lavorerò molto di più con quel set di dati in seguito. |
| |
Ma se volessi semplicemente adattare molto velocemente un modello di regressione lineare in R e ottenere i valori predittivi, puoi farlo. Certo, puoi farlo con JMP. Ma solo per dare un'idea molto semplice. |
| |
COSÌ, |
| |
una cosa da notare è che io uso R 3.6.3, ma JMP può gestire qualsiasi cosa purché sia maggiore di 2.9. |
| |
Allo stesso modo, con Python puoi richiamare la tua sessione Python. L'immagine mostra come ho adattato la regressione lineare con Python. Non spiegherò tutte le righe di codice, ma l'idea di base è chiara. |
| |
Ora, ovviamente, con Python bisogna fare un po' di attenzione, perché la versione più recente è la 3.8.5. Ma se usate Anaconda per installare cose, JMP ha problemi a comunicare con esso quando è maggiore della 3.6, quindi |
| |
poiché per questa dimostrazione utilizzo la versione 3.6.5. |
| |
E infine, possiamo creare anche la nostra sessione MATLAB. |
| |
Quindi qui uso MATLAB 2019b. Ma in pratica, se la tua versione di MATLAB è uscita negli ultimi sette o otto anni, dovrebbe funzionare benissimo. |
| |
Ok, quindi come colleghiamo tutto? In realtà, esamineremo un processo in quattro fasi. Per prima cosa, vogliamo adattare ogni modello. Quindi invieremo a ogni software i dati e indicheremo in quale set risiede ogni osservazione. |
| |
Una volta che i modelli sono adatti, vogliamo produrre tali adattamenti e le relative previsioni e aggiungerli a una tabella dati che JMP possa esaminare. |
| |
Quindi, ovviamente, il mio consiglio è di assicurarti di citare cose che ti permettano di capire dove ti sei inserito nel modello o come ti sei inserito nel modello. Ho esempi di entrambi i casi in arrivo. |
| |
Quindi, il terzo passo, a seconda del modello, potrebbe essere quello di esaminare alcune diagnosi del modello. Solo perché un modello si adatta... sembra adattarsi bene in base ai numeri, basta dare un'occhiata al grafico dei residui, ad esempio, e si può scoprire molto rapidamente... |
| |
l'area di maggiore interesse non è molto adatta. |
| |
Oppure c'è qualcosa che non va con i residui e così via. Quindi mostreremo come generare anche questo tipo di dati. |
| |
E infine useremo la piattaforma di confronto dei modelli, per riunire tutto in un'unica grande tabella e confrontare i numeri, molto più facilmente anziché dover continuamente sfogliare i dati avanti e indietro. |
| |
Bene, ora spiegheremo i passaggi in modo un po' più dettagliato. Per il primo passaggio, quello in cui eseguiamo l'adattamento del modello, abbiamo essenzialmente due opzioni. Per prima cosa, possiamo dire a JMP tramite JSL di chiamare il software che preferisci. |
| |
Inviagli i dati e il codice per adattarli. E così, in effetti, salterò fuori da qui per un attimo e farò esattamente questo. |
| |
Quindi, come vedi, ho un po' di codice per chiamare effettivamente R. |
| |
E poi, una volta fatto, chiamerò Python e, una volta fatto, chiameró MATLAB e poi collegherò tutto insieme. Ora parlerò più approfonditamente del codice tra poco, ma ci vorranno probabilmente tre o quattro minuti per eseguirlo. Quindi lo farò ora. |
| |
E torneremo da lui quando saremo pronti. |
| |
Quindi la nostra altra opzione è creare un set di dati con la convalida. Bene, creiamo un set di dati con la colonna di convalida e/o una colonna di test, a seconda di quanti |
| |
I set suddividevano i nostri dati. Siamo programmati per funzionare con qualsiasi software di cui abbiamo bisogno, ovviamente l'output da quel software è qualsiasi cosa di cui abbiamo bisogno. |
| |
Quindi, ovviamente, qualche avvertimento. Assicuratevi che... qualsiasi software stiate usando abbia effettivamente ciò che vi serve per adattarvi al modello. |
| |
Assicuratevi che il modello sia completamente assemblato prima di provare a confrontarlo con altri oggetti. |
| |
Assicuratevi che il formato di output sia effettivamente leggibile da JMP. Per fortuna JMP può leggere parecchie cose, quindi questo non è il più grave dei quattro avvisi. |
| |
Ma come vi ho già avvisato in precedenza, assicuratevi che le previsioni di ciascun modello corrispondano alle osservazioni corrette del set di dati originale. |
| |
E quindi torniamo al punto se si tratta di addestramento, se si tratta di un'osservazione di addestramento, quando la si inserisce in JMP, |
| |
Meglio che sia un'osservazione di training quando la si inserisce in qualsiasi software utilizzato. Se è validazione in JMP, sarà validazione altrove. È un test in JMP, sarà testato altrove. |
| |
Quindi, assicuratevi che le cose corrispondano correttamente, perché l'ultima cosa che vogliamo scoprire è guardare i set di test e dire: "Oh, questo si adatta molto meglio". Beh, è perché le osservazioni che si adattavano erano ponderate in modo diverso e non presentavano veri valori anomali. Quindi, questo finisce per distorcere il vostro ragionamento. |
| |
una parola di cautela, scusatemi, una parola di cautela. |
| |
Ok. Come ho accennato, ho un esempio che sto eseguendo in background. Quindi voglio fornire qualche dettaglio su quello che sto facendo. |
| |
A quanto pare, devo integrare le reti neurali in R, Python e MATLAB. Quindi, se voglio farlo, in R devo installare due pacchetti, oltre a quello di base, che ho già: il pacchetto Keras e il pacchetto Tensorflow. |
| |
numpy, pandas e matplotlib. |
| |
Quindi Numpy per fare calcoli abbastanza facilmente; Pandas, Pandas per elaborare dati... un po' di manipolazione dei dati; e Matplotlib dovrebbe essere abbastanza semplice per creare grafici. E poi in MATLAB uso la toolbox per il deep learning, anche se non hai accesso a quella. |
| |
Bene. Quindi, secondo passaggio, vogliamo aggiungere le previsioni alla tabella dati di JMP. Quindi, se usate JMP per richiamare il software, potete usare il codice JSL per recuperare tali previsioni e aggiungerle a una tabella dati, in modo da poterle confrontare in seguito. |
| |
Quindi l'altro modo in cui puoi procedere è far eseguire il software da solo e salvare l'output. Puoi rapidamente dire a JMP di estrarre quel file di output e quindi effettuare qualche manipolazione per importare le previsioni in qualsiasi tabella dati in cui hai memorizzato i risultati. |
| |
Ora possiamo anche leggere i grafici diagnostici. In questo caso, quello che farò generalmente è salvare i grafici diagnostici come file grafici. Quindi, per me, saranno file PNG. Ma ovviamente, qualunque sia il formato |
| |
Grafica che puoi usare. Ora, JMP non può coprire ogni singolo problema, ma credo che PNG possa mappare anche jpg e altri, e loro... coprono anche quelli che usi di solito. |
| |
Quindi la seconda nota la uso per la piattaforma di confronto dei modelli, ma per aiutare a identificare cosa...quale modello ti si addice e dove ti si addice, |
| |
In genere consiglio di aggiungere la seguente proprietà per ogni colonna di previsione che si aggiunge. Vediamo quindi che stiamo inviando alla tabella dati di interesse questa proprietà chiamata "previsione". |
| |
E quindi qui abbiamo qualunque cosa tu stia usando per prevedere le cose (ora, il valore probabilmente non è la scelta migliore qui), ma |
| |
Ma con questo creatore, questo mi dice, ehi, quale software ho usato per creare questo modello? E quindi qui ho usato R. Mostra R in modo che questo possa effettivamente stare sullo schermo. Python e MATLAB erano un po' troppo lunghi, ma possiamo inserire qualsiasi stringa vogliamo qui. |
| |
Li vedrete tra poco quando analizzerò il codice più nel dettaglio. |
| |
Quindi, e questo è utile perché in seguito inserirò più modelli in R. Quindi, se scelgo correttamente i nomi delle colonne e ne ho più di uno in cui R li ha creati, so comunque quale modello sto effettivamente guardando. |
| |
Bene, ecco come appare tipica la finestra di dialogo di confronto dei modelli. |
| |
Una cosa che voglio sottolineare è che, più o meno, questo è ciò che apparirebbe se facessi un puntamento e clic alla fine di tutto il fitting del modello. Come potete vedere, ho diversi predittori. Ho reti neurali per MATLAB, Python e R. |
| |
Varie forme di previsione; ho usato JMP per adattare alcune cose. |
| |
Ora, spesso ciò che la gente fa è mettere questa colonna di convalida come un gruppo, |
| |
In modo da raggruppare la convalida dell'addestramento e il test. In realtà, preferisco l'output quando lo inserisco nell'istruzione By qui. Lo mostrerò qui più avanti. Ma puoi inserirlo in entrambi i modi: |
| |
ma in sintesi, mi piace di più il risultato in questo modo. |
| |
Quindi questo è il motivo principale per cui ora posso vedere chiaramente che questi sono tutti gli allenamenti, |
| |
queste sono tutte le convalide (non dovrebbero essere visibili nelle intestazioni) e questi sono tutti i test. |
| |
Se usi la convalida come variabile di gruppo, otterrai una grande tabella con 21 voci. Ora ci sarà una colonna in più. Dice "test di convalida di training" o, nel mio caso, sarà 012, ma |
| |
In questo modo, con le parole, non devo pensare così tanto. Non devo spiegare a nessuno cosa significa 012 e così via. Ecco perché ho fatto la scelta che ho fatto. |
| |
Bene, nell'esempio che spiegherò qui, userò il classico set di dati del mercato immobiliare di Boston. Questo è incluso in JMP. Ecco perché non l'ho incluso come file nella mia presentazione, perché se avete JMP, lo avete già. |
| |
Quindi Harrison e Rubinfeld avevano diversi fattori predittivi del valore mediano della casa, come il tasso di criminalità pro capite, la proporzione di acri di attività commerciali non al dettaglio per città, |
| |
numero medio di stanze all'interno di qualsiasi cosa tu stia cercando di acquistare, rapporto tra studenti e insegnanti per città (quindi se ci sono molti insegnanti e non altrettanti studenti, questo generalmente significa che un'istruzione migliore è ciò che molte persone desiderano) |
| |
trovato) e molti altri. Non ho intenzione di esaminarli tutti e 13 qui. |
| |
Ok, lasciatemi dare un breve contesto sui modelli che ho esaminato qui. Poi approfondirò il codice JSL e come ho integrato il tutto. |
| |
Ho esaminato alcuni dei modelli. Innanzitutto, il modello di regressione lineare per eccellenza. Qui vedete una semplice regressione lineare. Ho semplicemente adattato il valore mediano, a quanto pare, all'aliquota fiscale. |
| |
Ma ovviamente userò una regressione lineare multipla e li utilizzerò tutti. |
| |
COSÌ, |
| |
Ma con 13 diversi predittori, e sapendo che alcuni di essi potrebbero essere correlati tra loro, ho deciso che forse valeva la pena prendere in considerazione anche altri tipi di regressione. |
| |
Uno di questi è qualcosa chiamato regressione a ponte. Quindi in realtà si tratta di una regressione lineare con essenzialmente un vincolo aggiunto che |
| |
i valori al quadrato dei miei parametri non possono essere maggiori di una certa costante. |
| |
Posso... a quanto pare posso effettivamente riscrivere questo come un problema di ottimizzazione in cui un valore di lambda corrisponde a un valore di C. |
| |
Quindi cerco solo di minimizzare questo problema con questo termine di penalità aggiuntivo, anziché con i tipici minimi quadrati a cui siete abituati. |
| |
Ora, questo si chiama metodo di restringimento perché, ovviamente, man mano che lo riduco sempre di più, tutti questi valori si avvicineranno sempre di più allo zero. Quindi, ovviamente, bisogna riflettere su quanto restrittivo voglio che sia. |
| |
Ora, con la riduzione, tutti si sposteranno lentamente verso lo zero. Ma con un altro tipo di termine di penalità, posso effettivamente eliminare del tutto alcuni termini. |
| |
E posso usare una cosa chiamata lazo. Quindi il vincolo qui è: ok, invece delle stime dei parametri al quadrato, prenderò semplicemente la somma del valore assoluto di quelle stime dei parametri. |
| |
E quindi si scopre che ciò che accadrà in realtà è che coloro che sono molto deboli otterranno le loro stime dei parametri impostate a zero, il che in un certo senso serve come un |
| |
eliminazione, se vogliamo, dei termini non importanti. |
| |
Quindi, per dare un'idea visiva di cosa fanno la regressione lazo e ridge, per la regressione ridge, il cerchio qui rappresenta il termine di penalità. |
| |
E qui stiamo esaminando lo spazio dei parametri. E quindi le stime dei minimi quadrati reali sarebbero qui. Quindi non ci stiamo arrivando, perché abbiamo questo vincolo aggiuntivo. |
| |
Quindi, alla fine, troviamo dove... dove otteniamo il valore minimo che tocca il cerchio, in pratica. E quindi queste sarebbero le nostre stime dei parametri di regressione di cresta. |
| |
Per il lazo, disegno simile, ma ora potete vedere, con il valore assoluto, che è più simile a un diamante che a un cerchio. Notate che si tratta di due dimensioni, ovviamente, e parleremo delle ipersfere e di tutte quelle forme. |
| |
Ma potete vedere qui, notate che tocca proprio la punta del diamante. E quindi in questo caso beta uno è in realtà zero. Ecco come si eliminano i termini. |
| |
Bene, un'altra cosa che vedremo è il cosiddetto albero di regressione. JMP usa le piattaforme di partizione per realizzarlo. Quindi, per darvi una rapida dimostrazione di ciò che mostra, ecco, ho tutti i miei dati. |
| |
E quindi la prima domanda che mi pongo è: quante stanze ci sono nell'abitazione? So che non posso avere 0,943 stanze, quindi sostanzialmente... |
| |
Ho sei stanze o meno. Quindi scendiamo da questa parte dell'albero, non scendiamo da questa parte. Ora, se ho sette stanze o più, questo mi dice immediatamente che prevedrò la mia mediana. |
| |
il valore sia 37. Ricorda che si tratta di decine di migliaia di dollari, quindi diciamo $ 370.000. |
| |
Se è inferiore a sette, allora la domanda successiva che mi sono posto è: quanto è grande lstat? |
| |
Quindi, se è maggiore o uguale a 14,43, guardo questo nodo e improvvisamente la mia stima media per un'abitazione è di circa 150.000 dollari, mentre se vengo qui, sarà di circa 233.000 dollari. |
| |
Quindi, ciò che fanno realmente gli alberi di regressione è suddividere lo spazio di input in aree diverse. E forniamo la stessa previsione a ogni valore all'interno di quell'area. |
| |
Quindi, come puoi vedere, ho suddiviso...ora, in questo caso, ne prendo uno bidimensionale perché è più facile da disegnare... |
| |
E quindi potete vedere questo albero qui, dove per prima cosa guardo x1. Ora guardo x2 qui e faccio un'altra domanda su x1 e un'altra domanda su x2, ed è così che finisco per partizionare lo spazio di input. |
| |
Ora, ognuno di questi cinque avrà un valore di previsione. Ed è essenzialmente così che appare. Lo guardo dall'alto. Otterrò esattamente questo. Ma potete vedere qui che |
| |
la previsione è leggermente diversa a seconda di quale delle cinque aree è corretta. |
| |
Ora, non entrerò troppo nei dettagli su come adattarne esattamente uno, ma |
| |
James, Witten, Tibshirani e Friedman ne danno un piccolo contributo; Leo ??? ha scritto un libro fondamentale sull'argomento, quindi potete dargli un'occhiata lì. |
| |
Quindi, ora parlerò delle reti neurali, che sono molto utilizzate oggigiorno nell'apprendimento automatico e in altri ambiti. Questo esempio fornisce un'immagine di come appare una rete neurale. Qui, questa immagine utilizza solo 5 input e 13 input quando vengono passati. |
| |
a questi... questo strato nascosto. E ognuno di questi viene trasformato tramite una funzione di attivazione. |
| |
E per ciascuna di queste funzioni di attivazione, si ottiene un output e noi useremo... |
| |
Spesso utilizziamo semplicemente una regressione lineare di questi output per prevedere il valore mediano. |
| |
Va bene, quindi |
| |
In realtà, le reti neurali sono modelli non lineari, in fin dei conti, e in realtà sono chiamate reti neurali perché la rappresentazione generale è quella in cui immaginiamo il funzionamento dei neuroni nel cervello umano. |
| |
Quindi ogni input può essere passato ai nodi in un livello nascosto. A livello nascosto, gli input vengono inviati tramite una funzione di attivazione e viene calcolato un output. Ogni output può essere passato a un nodo in un altro livello nascosto o essere un output della rete. |
| |
Ora in JMP sono consentiti solo due livelli nascosti. |
| |
A dire il vero, per quanto riguarda la creazione di una rete neurale, non c'è niente che dica che non puoi averne 20 per tutto ciò |
| |
Ciò che ci preoccupa ora. A dire il vero, c'è una teoria statistica che suggerisce che, ehi, possiamo approssimare qualsiasi funzione continua, |
| |
date alcune condizioni al contorno, con due livelli nascosti. Quindi è probabile che sia questo il motivo per cui JMP ha preso questa decisione. |
| |
base lineare, tangente iperbolica e base radiale gaussiana. Quindi, in effetti, |
| |
Su questi nodi, notate la piccola curva qui. Credo che sia per la funzione tangente iperbolica; lineare sarà una linea retta che sale; e la base radiale gaussiana, credo, assomiglierà più a una curva normale. |
| |
Questa è la piattaforma di reti neurali. Quindi l'ultima che vedremo è una cosa chiamata regressione di ricerca di proiezione. Volevo fare un esempio concreto di qualcosa che JMP semplicemente non riesce a fare. |
| |
Ehm, quindi la regressione con proiezione di ricerca era un modello originariamente proposto da Jerome Friedman e Steutzle a Stanford. Il loro modello prende in considerazione le previsioni... fa previsioni nella forma y uguale alla somma di beta i, f sub i e una trasformazione lineare degli input. |
| |
Quindi in realtà questo è in qualche modo analogo a una rete neurale. Qui hai un livello nascosto con k nodi, ognuno con funzione di attivazione fi. |
| |
L. Si scopre che con la regressione di proiezione, stimeremo effettivamente anche questi f sub i. |
| |
Generalmente si tratterà di una sorta di smoother o di un fit spline. Tipicamente, le f sub i sono chiamate funzioni di cresta. Ora abbiamo alfa, beta e F su cui dobbiamo ottimizzare. Quindi, in genere, viene eseguito un fitting stagewise. Non entrerò troppo nei dettagli in questo momento. |
| |
Ok, ho esaminato tutti i miei modelli. |
| |
Ora mostrerò un po' di output e spero che tutto vada bene. Una cosa che voglio sottolineare prima di entrare in JMP è che |
| |
È davvero difficile impostare i seed per le reti neurali in R, Python per Keras. Quindi tieni presente che se prendi il mio codice e lo esegui, probabilmente non otterrai esattamente quello che ho ottenuto io, ma dovrebbe essere abbastanza simile. Detto questo, |
| |
Vediamo cosa abbiamo ottenuto. Quindi questo è stato il risultato che ho ottenuto. Ora, purtroppo, le cose non sembrano essere andate alla perfezione. |
| |
COSÌ, |
| Lucas |
Cosa ho qui? Quindi ho il mio training, la mia validazione e il mio test. E quindi ci accorgiamo molto rapidamente che uno di questi modelli non si adattava molto bene. Purtroppo, alla rete neurale di R è successo qualcosa di terribile. |
| |
Deve aver preso una brutta posizione nello spazio di input da cui partire e quant'altro. E quindi non si adattava a un modello molto valido. |
| |
Sfortunatamente, i parametri iniziali nei modelli non lineari sono importanti; in alcuni casi, veniamo morsi da essi. |
| |
Ma se diamo un'occhiata a tutto il resto, tutto il resto sembra andare abbastanza bene. Ora, su cosa sia abbastanza bene, possiamo discuterne, ma vedo R quadrati, uno sopra 0,5. Vedo la radice media. |
| |
Gli errori quadratici qui si aggirano intorno a cinque, e anche i nostri errori assoluti medi si attestano intorno al tre. Ora, per quanto riguarda l'addestramento, sembra che le regressioni basate sul metodo di proiezione abbiano funzionato meglio. |
| |
Se considero il set di dati di convalida, sembra ancora R |
| |
Il metodo di ricerca della proiezione ha avuto i risultati migliori. Ma se guardiamo il set di dati di test, all'improvviso, no, la regressione del metodo di ricerca della proiezione è risultata seconda, supponendo di ignorare la rete neurale di R, la seconda peggiore. |
| |
Spesso, in un framework come questo, prendiamo in esame il set di dati di prova come quello più attendibile, perché non è stato utilizzato in alcun modo, forma o aspetto per determinare l'adattamento del modello. |
| |
E in base a ciò vediamo che sembra |
| |
la regressione ridge di JMP si adatta meglio. |
| |
Possiamo vedere qui sopra, il suo R quadrato era 0,71 qui prima era circa 0,73, e circa 0,73 qui, quindi possiamo vedere che è costantemente adatto |
| |
la stessa cosa in tutti e tre i set di dati. Quindi, se fossi costretto a prendere una decisione, basandomi solo su ciò che vedo al momento, probabilmente opterei per |
| |
La regressione di cresta. Detto questo, abbiamo un sacco di dati diagnostici e quant'altro qui sotto. Quindi, se voglio guardare cosa è successo con quella rete neurale di R, |
| |
Vedo subito che è successo qualcosa a pochi passi da lì. Come puoi vedere, sta facendo un pessimo lavoro di adattamento, perché praticamente tutto è previsto a 220 mila. |
| |
Sappiamo quindi che qualcosa è andato storto durante il montaggio. |
| |
Abbiamo visto che la regressione ridge sembrava la migliore. Diamo un'occhiata a cosa produce. Tra un attimo vi mostrerò il mio codice JSL molto velocemente: |
| |
Mostra come ho fatto tutto questo, ma, ehm, possiamo vedere qui le stime dei parametri della regressione di cresta. Possiamo vedere i grafici diagnostici di cresta, quindi le cose non si sono ridotte troppo rispetto alle stime originali. |
| |
Come si può vedere dai test di convalida con log come non fatto. |
| |
E qui a destra, abbiamo i nostri grafici essenzialmente residuali. Questi sono quelli effettivi e quelli previsti. |
| |
Quindi, come potete vedere dall'addestramento, sembra che ce ne fossero alcuni piuttosto costosi che non sono stati previsti molto bene. Ne vediamo meno qui rispetto al set di test, ma non sembra che abbiamo avuto troppi problemi. Abbiamo un paio di punti un po' strani qui, ma possiamo vedere in generale |
| |
Quando ci troviamo in case a basso prezzo, i dati si adattano abbastanza bene a tutti e tre i set. Di nuovo, potremmo chiederci cosa sia successo in questi casi, ma, |
| |
Al momento, questo sembra essere il migliore del gruppo. Quindi possiamo vedere cosa pensano gli altri. |
| |
Guarda qui. Quindi diamo un'occhiata a MATLAB per un momento. |
| |
Quindi potete vedere anche la convalida del test di training qui. Quindi qui stiamo sputando fuori... MATLAB sputa fuori una cosa di diagnostica e potete vedere che ci sono volute alcune epoche per completarla, quindi. |
| |
Ma fortunatamente MATLAB, come possiamo vedere, è abbastanza veloce. |
| |
E poi quello effettivo previsto qui. |
| |
Possiamo vedere tutto questo. |
| |
Ok, ora mi prenderò qualche minuto per dare un'occhiata al codice. |
| |
Quindi, ovviamente, ecco alcune note: assicuratevi che tutto sia installato in modo da poter effettivamente eseguire il tutto, perché in caso contrario, JMP fallirà miseramente, non sputerà previsioni e poi fallirà perché non riesce a trovarle. |
| |
Quindi JMP ha la possibilità di creare una colonna di convalida tramite codice. Quindi l'ho fatto, scegliendo 60 20 20. Ho scelto quel seed casuale qui in modo da poter utilizzare gli stessi set di test di convalida di training che uso io. |
| |
Quindi, per il momento, quello che faccio è salvare le colonne training, validation e test. In realtà, eliminerò quella colonna per un po'. |
| |
Il motivo per cui lo faccio qui è perché invio il set di dati a R, Python e MATLAB ed è più facile scrivere il codice quando tutto ciò che contiene è o l'output o tutti gli input. |
| |
Quindi non volevo una colonna di convalida che non lo fosse, e poi diventa un po' più difficile farlo. Quindi quello che ho fatto alla fine è stato inviare il set di dati, |
| |
Ho inviato le righe di training, validazione e test, e poi ho chiamato il codice R per eseguirlo. Ora puoi effettivamente |
| |
Inserisci qui il codice R vero e proprio. Ho scelto di scrivere solo una riga qui per non dover scorrere all'infinito. Ma niente te lo impedisce. Se si tratta solo di poche righe di codice, come quelle che hai visto prima nella presentazione, le incollerei direttamente qui. |
| |
Quindi, una volta fatto, si scopre...questo codice sputa fuori |
| |
Un'immagine della diagnostica. Abbiamo visto che si è fermato dopo sei o sette iterazioni, diciamo che è finita. |
| |
E ho anche inserito la regressione di cresta in questo script, quindi otteniamo due immagini. Quindi ho estratto anche quella, l'ho salvata e ho creato un riquadro. Ora, ho messo insieme il tutto alla fine del codice. |
| |
Quindi ottengo l'output e tra poco aggiungerò i dati alla tabella qui. |
| |
Ok, ecco un po' di codice. Supponiamo di avere 6 milioni di osservazioni e che ci vogliano 24 ore per adattare effettivamente il modello; probabilmente non vorrai eseguirlo in JMP. |
| |
Quindi, come piccolo pezzo di codice che potresti fare da qui, puoi dire, ehi, sono |
| |
Ok, aprirò la tabella dati che mi interessa. Nel frattempo, dirò a R di eseguirla da qualche altra parte e, una volta che il mio sistema mi darà il via libera, potrò dire: "Ok, apri l'output da quella tabella e importalo in |
| |
la mia tabella dati. Quindi questo potrebbe essere un modo per fare alcune di queste cose. E ovviamente vuoi salvare il file immagine da qualche parte e usare anche questo codice. Ma questo sarà esattamente lo stesso codice. |
| |
Ok, quindi per Python sarà molto simile. Gli passerò queste cose. Eseguirò un po' di codice Python, mostrerò il grafico diagnostico e le previsioni. |
| |
E vi allego un po' di codice Python, come potete vedere, è molto, molto simile a quello che abbiamo fatto con JMP. In questo caso, apro un file CSV. Copio la colonna e la chiudo, perché non mi serve più. |
| |
E poi di nuovo MATLAB, esattamente lo stesso gioco. Risorse, eseguo lo script MATLAB. Ottengo il file PNG che ho sputato fuori da qui. Lo salvo dove mi serve, salvo le previsioni. E se serve, lo prendo. |
| |
invece di eseguirlo dall'interno, un breve codice di esempio può farlo. |
| |
Bene, ora che ho finito di chiamare R, Python e Matlab, riporto le mie colonne di convalida in modo che JMP possa usarle. Quindi, ricordo quale è quale. |
| |
Quindi, per impostazione predefinita, JMP esamina i valori all'interno della colonna di convalida che useremo. Il valore più piccolo è quello di training, il successivo più grande è quello di convalida, il più grande è quello di test. Ora, se si esegue una convalida incrociata K-fold, JMP indicherà di quale piega si tratta. Quindi, scorrendo per 012345678 e così via. |
| |
Quindi crea questo. A mia volta ho creato anche questo qui, in modo che invece di 012, nel mio output verrà effettivamente scritto training, validation e test, quindi è un po' più chiaro |
| |
Capisco. Quindi, se lo mostro a qualcuno che non ha mai usato JMP prima, non saprà cosa significa 012, ma dovrebbe sapere cosa sono training, validation e test. |
| |
Ok, ora inizio ad aggiungere le previsioni alla mia tabella dati. Ecco la proprietà set a cui ho accennato prima nel mio intervento. |
| |
Quindi, il MATLAB del mio creatore... ho dato un nome alla colonna, quindi... ehi, so che è la previsione della rete neurale per MATLAB. Quindi potrei non aver necessariamente bisogno del creatore, ma nel caso fossi un po' impreciso nel dare nomi alle cose... |
| |
Mi dispiace. |
| |
Quindi possiamo ottenere tutta la regressione di ricerca della proiezione, le reti neurali e quant'altro. |
| |
Poi ho anche notato che, ehi, ho adattato la regressione ridge, lazo e la regressione lineare in JMP. |
| |
Quindi ho fatto tutto qui. Quindi qui faccio il mio modello di adattamento, la mia regressione generalizzata. Tira fuori tutto questo sputo. |
| |
Salva le mie formule di previsione. |
| |
Rappresenta graficamente il mio output effettivo con quello previsto per ottenere il risultato finale completo. |
| |
E adatterò la mia rete neurale. Potrei dire la colonna di convalida? Trasferisco le mie covariate. Generalmente le reti neurali tendono ad adattarsi un po' meglio quando scaliamo le cose intorno allo zero, rispetto a qualsiasi valore di output si trovi di solito. |
| |
Quindi il mio primo livello nascosto ha tre nodi. Il mio secondo livello nascosto ne ha due. Qui sono entrambe funzioni di attivazione lineare. A quanto pare, per i tre livelli sopra, uso la funzione di attivazione delle unità lineari ristrette, quindi leggermente diversa. |
| |
ma ho scoperto che in ogni caso sembrano adattarsi più o meno allo stesso modo. |
| |
5. Ciò significa che proverò cinque diverse serie di valori iniziali e terrò quello che funziona meglio. |
| |
Come puoi vedere dal mio codice, probabilmente avrei dovuto farlo con R. Ha fatto una specie di ciclo a quattro, ne ha fatti diversi, e ha tirato fuori quello che funziona meglio. Quindi, per lavori futuri, questo sarebbe un punto su cui mi baserei. |
| |
Quindi salvo tutto e sono pronto per il confronto tra modelli. Ora inserisco tutte quelle nuove colonne nel confronto tra modelli. |
| |
Scorri un po'. Eccomi qui a convalidare, come ho accennato prima. |
| |
E quindi, alla fine, sto solo scrivendo un po' di codice per far sì che sostanzialmente abbia l'aspetto che voglio. |
| |
Quindi ottengo queste caselle di riepilogo, solo per dire diagnosi di addestramento, diagnosi di convalida, diagnosi di test, invece delle solite cose che dice JMP. |
| |
Voglio ottenere questi grafici diagnostici. |
| |
Ora, quello che voglio dire è che voglio solo una parte dei risultati ottenuti con la gestione di questa cosa. |
| |
Farò velocemente alcuni grafici residui perché non tutti li mostrano immediatamente, in particolare quelli di MATLAB, Python e R. |
| |
Imposto quei titoli e poi creo semplicemente la grande vecchia tabella o il grande vecchio dialogo. |
| |
E poi scrivo tutto nel mio diario. |
| |
In modo che sia pulito e ordinato. Chiudo un sacco di cose, così non devo preoccuparmene. E poi quello che ho fatto qui alla fine è quello che volevo che succedesse quando ne aprissi uno, |
| |
tutto il resto sotto di esso è immediatamente aperto piuttosto che |
| |
dover cliccare su sei o sette cose diverse. Vedi, devo cliccare qui e qui e |
| |
Qui ce ne sono altri tre. Credo che ce ne sia ancora uno. Scusate. Ma così non devo cliccare su nessuno di questi, si aprono automaticamente. |
| |
Ecco cosa fa quest'ultima parte di codice. |
| |
Va bene. |
| Lucas |
Quindi, questo è semplicemente diverso: lo si può produrre e mandare in onda. Ma è anche così che potrebbe apparire. |
| |
Quindi, come ho detto, nel codice avete visto qualcosa di diverso, questo è ciò che abbiamo visto. |
| |
Riccardo |
| Lucas |
No. Quindi, per concludere, la piattaforma di confronto modelli è davvero uno strumento molto utile per confrontare la capacità predittiva di più modelli in un unico posto. Non è necessario passare continuamente da un modello all'altro. È sufficiente osservare tutto ciò che si ha davanti. |
| |
La flessibilità può essere utilizzata anche per adattare modelli che non erano adatti in JMP o confrontare modelli che non erano nemmeno adatti in JMP. E così |
| |
In questo modo, se dobbiamo adattare modelli molto grandi che richiedono molto tempo per essere adattati, possiamo dire loro di procedere. Estraiamo tutto in JMP e analizziamo facilmente tutti i risultati per cercare di determinare i passaggi successivi. |
| |
E con questo, grazie per il tuo tempo. |
