Apprendimento automatico con Python - Guida rapida

Viviamo nell'era dei dati che si arricchisce di una migliore potenza di calcolo e di più risorse di archiviazione. Questi dati o informazioni aumentano di giorno in giorno, ma la vera sfida è dare un senso a tutti i dati. Le aziende e le organizzazioni stanno cercando di affrontarlo costruendo sistemi intelligenti utilizzando i concetti e le metodologie di Data science, Data mining e Machine learning. Tra questi, l'apprendimento automatico è il campo più interessante dell'informatica. Non sarebbe sbagliato se chiamassimo apprendimento automatico l'applicazione e la scienza degli algoritmi che forniscono un senso ai dati.

Cos'è l'apprendimento automatico?

L'apprendimento automatico (ML) è quel campo dell'informatica con l'aiuto del quale i sistemi informatici possono fornire un senso ai dati più o meno allo stesso modo degli esseri umani.

In parole semplici, ML è un tipo di intelligenza artificiale che estrae modelli da dati grezzi utilizzando un algoritmo o un metodo. L'obiettivo principale del ML è consentire ai sistemi informatici di apprendere dall'esperienza senza essere programmati esplicitamente o l'intervento umano.

Necessità di machine learning

Gli esseri umani, in questo momento, sono le specie più intelligenti e avanzate della terra perché sanno pensare, valutare e risolvere problemi complessi. D'altra parte, l'IA è ancora nella sua fase iniziale e non ha superato l'intelligenza umana in molti aspetti. Allora la domanda è: qual è la necessità di far apprendere alla macchina? La ragione più adatta per farlo è "prendere decisioni, basate sui dati, con efficienza e scalabilità".

Ultimamente, le organizzazioni stanno investendo molto in tecnologie più recenti come Intelligenza Artificiale, Machine Learning e Deep Learning per ottenere le informazioni chiave dai dati per eseguire diverse attività del mondo reale e risolvere i problemi. Possiamo chiamarle decisioni guidate dai dati prese dalle macchine, in particolare per automatizzare il processo. Queste decisioni basate sui dati possono essere utilizzate, invece di utilizzare la logica di programmazione, nei problemi che non possono essere programmati intrinsecamente. Il fatto è che non possiamo fare a meno dell'intelligenza umana, ma un altro aspetto è che tutti dobbiamo risolvere i problemi del mondo reale con efficienza su vasta scala. Ecco perché nasce la necessità dell'apprendimento automatico.

Perché e quando far imparare le macchine?

Abbiamo già discusso della necessità del machine learning, ma sorge un'altra domanda: in quali scenari dobbiamo far apprendere alla macchina? Possono esserci diverse circostanze in cui abbiamo bisogno che le macchine prendano decisioni basate sui dati con efficienza e su vasta scala. Le seguenti sono alcune delle circostanze in cui fare in modo che le macchine apprendano sarebbe più efficace:

Mancanza di esperienza umana

Il primo scenario in cui vogliamo che una macchina apprenda e prenda decisioni basate sui dati può essere il dominio in cui manca la competenza umana. Gli esempi possono essere navigazioni in territori sconosciuti o pianeti spaziali.

Scenari dinamici

Ci sono alcuni scenari di natura dinamica, cioè continuano a cambiare nel tempo. In caso di questi scenari e comportamenti, vogliamo che una macchina apprenda e prenda decisioni basate sui dati. Alcuni degli esempi possono essere la connettività di rete e la disponibilità dell'infrastruttura in un'organizzazione.

Difficoltà nel tradurre le competenze in compiti computazionali

Ci possono essere vari domini in cui gli esseri umani hanno la loro esperienza; tuttavia, non sono in grado di tradurre questa esperienza in compiti computazionali. In tali circostanze, vogliamo l'apprendimento automatico. Gli esempi possono essere i domini del riconoscimento vocale, compiti cognitivi ecc.

Modello di machine learning

Prima di discutere il modello di apprendimento automatico, dobbiamo comprendere la seguente definizione formale di ML fornita dal professor Mitchell:

"Si dice che un programma per computer impari dall'esperienza E rispetto ad alcune classi di compiti T e misura delle prestazioni P, se le sue prestazioni nei compiti in T, misurate da P, migliorano con l'esperienza E."

La definizione di cui sopra si concentra fondamentalmente su tre parametri, anche i componenti principali di qualsiasi algoritmo di apprendimento, vale a dire Task (T), Performance (P) ed esperienza (E). In questo contesto, possiamo semplificare questa definizione come:

ML è un campo dell'IA costituito da algoritmi di apprendimento che:

• Migliora le loro prestazioni (P)

• Durante l'esecuzione di un compito (T)

• Nel tempo con l'esperienza (E)

Sulla base di quanto sopra, il diagramma seguente rappresenta un modello di machine learning:

Parliamone più in dettaglio ora -

Compito (T)

Dal punto di vista del problema, possiamo definire il compito T come il problema del mondo reale da risolvere. Il problema può essere qualsiasi cosa come trovare il miglior prezzo della casa in una posizione specifica o trovare la migliore strategia di marketing ecc. D'altra parte, se parliamo di apprendimento automatico, la definizione di attività è diversa perché è difficile risolvere attività basate su ML approccio di programmazione convenzionale.

Si dice che un'attività T sia un'attività basata su ML quando è basata sul processo e il sistema deve seguire per operare sui punti dati. Gli esempi di attività basate su ML sono Classificazione, Regressione, Annotazione strutturata, Clustering, Trascrizione ecc.

Esperienza (E)

Come suggerisce il nome, è la conoscenza acquisita dai punti dati forniti all'algoritmo o al modello. Una volta fornito il set di dati, il modello verrà eseguito in modo iterativo e apprenderà alcuni pattern intrinseci. L'apprendimento così acquisito si chiama esperienza (E). Facendo un'analogia con l'apprendimento umano, possiamo pensare a questa situazione come in cui un essere umano sta imparando o acquisendo esperienza da vari attributi come situazione, relazioni, ecc. L'apprendimento supervisionato, non supervisionato e di rinforzo sono alcuni modi per apprendere o acquisire esperienza. L'esperienza acquisita dal nostro modello o algoritmo ML verrà utilizzata per risolvere il compito T.

Prestazioni (P)

Si suppone che un algoritmo ML svolga un'attività e acquisisca esperienza con il passare del tempo. La misura che dice se l'algoritmo ML sta funzionando come previsto o meno è la sua performance (P). P è fondamentalmente una metrica quantitativa che racconta come un modello sta eseguendo l'attività, T, usando la sua esperienza, E. Ci sono molte metriche che aiutano a comprendere le prestazioni di ML, come il punteggio di precisione, il punteggio F1, la matrice di confusione, la precisione, il richiamo , sensibilità ecc.

Sfide nell'apprendimento delle macchine

Mentre l'apprendimento automatico è in rapida evoluzione, facendo passi da gigante con la sicurezza informatica e le auto autonome, questo segmento dell'IA nel suo complesso ha ancora molta strada da fare. Il motivo è che il ML non è stato in grado di superare una serie di sfide. Le sfide che il ML sta affrontando attualmente sono:

Quality of data- Disporre di dati di buona qualità per gli algoritmi ML è una delle maggiori sfide. L'utilizzo di dati di bassa qualità porta ai problemi relativi alla preelaborazione dei dati e all'estrazione delle caratteristiche.

Time-Consuming task - Un'altra sfida affrontata dai modelli ML è il consumo di tempo soprattutto per l'acquisizione dei dati, l'estrazione e il recupero delle caratteristiche.

Lack of specialist persons - Poiché la tecnologia ML è ancora nella sua fase iniziale, la disponibilità di risorse esperte è un lavoro arduo.

No clear objective for formulating business problems - Non avere un obiettivo chiaro e ben definito per i problemi aziendali è un'altra sfida chiave per il ML perché questa tecnologia non è ancora così matura.

Issue of overfitting & underfitting - Se il modello è overfitting o underfitting, non può essere rappresentato bene per il problema.

Curse of dimensionality- Un'altra sfida che il modello ML deve affrontare sono le troppe funzionalità dei punti dati. Questo può essere un vero ostacolo.

Difficulty in deployment - La complessità del modello ML ne rende abbastanza difficile l'implementazione nella vita reale.

Applicazioni di Machine Learning

Il machine learning è la tecnologia in più rapida crescita e secondo i ricercatori siamo nell'anno d'oro dell'intelligenza artificiale e del machine learning. Viene utilizzato per risolvere molti problemi complessi del mondo reale che non possono essere risolti con l'approccio tradizionale. Di seguito sono riportate alcune applicazioni del mondo reale di ML:

• Analisi delle emozioni

• Analisi del sentiment

• Rilevamento e prevenzione degli errori

• Previsioni e previsioni meteorologiche

• Analisi e previsioni del mercato azionario

• Sintesi vocale

• Riconoscimento vocale

• Segmentazione della clientela

• Riconoscimento di oggetti

• Intercettazione di una frode

• Prevenzione frodi

• Raccomandazione dei prodotti al cliente nello shopping online.

Un'introduzione a Python

Python è un popolare linguaggio di programmazione orientato agli oggetti con le capacità del linguaggio di programmazione di alto livello. La sua sintassi facile da imparare e la capacità di portabilità lo rendono popolare in questi giorni. I fatti seguenti ci danno l'introduzione a Python:

• Python è stato sviluppato da Guido van Rossum allo Stichting Mathematisch Centrum nei Paesi Bassi.

• È stato scritto come il successore del linguaggio di programmazione denominato "ABC".

• La sua prima versione è stata rilasciata nel 1991.

• Il nome Python è stato scelto da Guido van Rossum da uno show televisivo chiamato Monty Python's Flying Circus.

• È un linguaggio di programmazione open source, il che significa che possiamo scaricarlo gratuitamente e utilizzarlo per sviluppare programmi. Può essere scaricato da www.python.org .

• Il linguaggio di programmazione Python ha le caratteristiche di Java e C sia. Ha l'elegante codice "C" e d'altra parte, ha classi e oggetti come Java per la programmazione orientata agli oggetti.

• È un linguaggio interpretato, il che significa che il codice sorgente del programma Python verrà prima convertito in bytecode e quindi eseguito dalla macchina virtuale Python.

Punti di forza e di debolezza di Python

Ogni linguaggio di programmazione ha alcuni punti di forza oltre che di debolezza, così come Python.

Punti di forza

Secondo studi e sondaggi, Python è il quinto linguaggio più importante nonché il linguaggio più popolare per l'apprendimento automatico e la scienza dei dati. È a causa dei seguenti punti di forza che Python ha:

Easy to learn and understand- La sintassi di Python è più semplice; quindi è relativamente facile, anche per i principianti, imparare e capire la lingua.

Multi-purpose language - Python è un linguaggio di programmazione multiuso perché supporta la programmazione strutturata, la programmazione orientata agli oggetti e la programmazione funzionale.

Huge number of modules- Python ha un numero enorme di moduli per coprire ogni aspetto della programmazione. Questi moduli sono facilmente disponibili per l'uso, quindi rendono Python un linguaggio estensibile.

Support of open source community- Essendo un linguaggio di programmazione open source, Python è supportato da una comunità di sviluppatori molto ampia. Per questo motivo, i bug vengono facilmente risolti dalla comunità Python. Questa caratteristica rende Python molto robusto e adattabile.

Scalability - Python è un linguaggio di programmazione scalabile perché fornisce una struttura migliorata per supportare programmi di grandi dimensioni rispetto agli script di shell.

Debolezza

Sebbene Python sia un linguaggio di programmazione popolare e potente, ha il suo punto debole nella velocità di esecuzione lenta.

La velocità di esecuzione di Python è lenta rispetto ai linguaggi compilati perché Python è un linguaggio interpretato. Questa può essere la principale area di miglioramento per la comunità Python.

Installazione di Python

Per lavorare in Python, dobbiamo prima installarlo. Puoi eseguire l'installazione di Python in uno dei seguenti due modi:

• Installazione di Python individualmente

• Utilizzo della distribuzione Python preconfezionata - Anaconda

Discutiamoli ciascuno in dettaglio.

Installazione di Python individualmente

Se vuoi installare Python sul tuo computer, allora devi scaricare solo il codice binario applicabile per la tua piattaforma. La distribuzione Python è disponibile per piattaforme Windows, Linux e Mac.

Quella che segue è una rapida panoramica dell'installazione di Python sulle piattaforme sopra menzionate:

On Unix and Linux platform

Con l'aiuto dei seguenti passaggi, possiamo installare Python su piattaforma Unix e Linux -

• Per prima cosa, vai a https://www.python.org/downloads/.

• Quindi, fare clic sul collegamento per scaricare il codice sorgente zippato disponibile per Unix / Linux.

• Ora, scarica ed estrai i file.

• Successivamente, possiamo modificare il file Modules / Setup se vogliamo personalizzare alcune opzioni.

  • Quindi, scrivi il comando run ./configure script

  • make

  • fare installazione

On Windows platform

Con l'aiuto dei seguenti passaggi, possiamo installare Python sulla piattaforma Windows -

• Per prima cosa, vai a https://www.python.org/downloads/.

• Quindi, fare clic sul collegamento per il file python-XYZ.msi del programma di installazione di Windows. Qui XYZ è la versione che desideriamo installare.

• Ora dobbiamo eseguire il file scaricato. Ci porterà alla procedura guidata di installazione di Python, che è facile da usare. Ora, accetta le impostazioni predefinite e attendi fino al termine dell'installazione.

On Macintosh platform

Per Mac OS X, Homebrew, si consiglia un programma di installazione di pacchetti fantastico e facile da usare per installare Python 3. Nel caso in cui non si disponga di Homebrew, è possibile installarlo con l'aiuto del seguente comando:

$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"

Può essere aggiornato con il comando sottostante -

$ brew update

Ora, per installare Python3 sul tuo sistema, dobbiamo eseguire il seguente comando:

$ brew install python3

Utilizzo della distribuzione Python preconfezionata: Anaconda

Anaconda è una raccolta pacchettizzata di Python che include tutte le librerie ampiamente utilizzate nella scienza dei dati. Possiamo seguire i seguenti passaggi per configurare l'ambiente Python usando Anaconda -

Step1- Per prima cosa, dobbiamo scaricare il pacchetto di installazione richiesto dalla distribuzione di Anaconda. Il collegamento per lo stesso èhttps://www.anaconda.com/distribution/. Puoi scegliere tra Windows, Mac e Linux OS secondo le tue esigenze.

Step2- Quindi, seleziona la versione di Python che desideri installare sulla tua macchina. L'ultima versione di Python è la 3.7. Lì otterrai le opzioni per il programma di installazione grafico a 64 bit e 32 bit entrambi.

Step3- Dopo aver selezionato il sistema operativo e la versione di Python, scaricherà il programma di installazione di Anaconda sul tuo computer. Ora, fai doppio clic sul file e il programma di installazione installerà il pacchetto Anaconda.

Step4 - Per verificare se è installato o meno, apri un prompt dei comandi e digita Python come segue -

Puoi anche verificarlo in una conferenza video dettagliata suhttps://www.tutorialspoint.com/python_essentials_online_training/getting_started_with_anaconda.asp.

Perché Python per la scienza dei dati?

Python è il quinto linguaggio più importante e il linguaggio più popolare per l'apprendimento automatico e la scienza dei dati. Le seguenti sono le caratteristiche di Python che lo rendono la scelta di linguaggio preferita per la scienza dei dati:

Ampio set di pacchetti

Python ha un ampio e potente set di pacchetti pronti per essere utilizzati in vari domini. Ha anche pacchetti come numpy, scipy, pandas, scikit-learn ecc. Che sono necessari per l'apprendimento automatico e la scienza dei dati.

Facile prototipazione

Un'altra caratteristica importante di Python che lo rende la scelta del linguaggio per la scienza dei dati è la prototipazione facile e veloce. Questa funzione è utile per sviluppare un nuovo algoritmo.

Funzionalità di collaborazione

Il campo della scienza dei dati ha fondamentalmente bisogno di una buona collaborazione e Python fornisce molti strumenti utili che lo rendono estremamente.

Una lingua per molti domini

Un tipico progetto di data science include vari domini come l'estrazione dei dati, la manipolazione dei dati, l'analisi dei dati, l'estrazione delle funzionalità, la modellazione, la valutazione, la distribuzione e l'aggiornamento della soluzione. Poiché Python è un linguaggio multiuso, consente al data scientist di affrontare tutti questi domini da una piattaforma comune.

Componenti dell'ecosistema Python ML

In questa sezione, discutiamo di alcune librerie di Data Science di base che formano i componenti dell'ecosistema di apprendimento automatico di Python. Questi componenti utili rendono Python un linguaggio importante per la scienza dei dati. Sebbene ci siano molti di questi componenti, discutiamo qui alcuni dei componenti importanti dell'ecosistema Python:

Jupyter Notebook

I notebook Jupyter forniscono fondamentalmente un ambiente computazionale interattivo per lo sviluppo di applicazioni di Data Science basate su Python. In precedenza sono noti come notebook ipython. Le seguenti sono alcune delle caratteristiche dei notebook Jupyter che lo rendono uno dei migliori componenti dell'ecosistema Python ML:

• I taccuini Jupyter possono illustrare il processo di analisi passo dopo passo organizzando le cose come codice, immagini, testo, output ecc. In modo graduale.

• Aiuta un data scientist a documentare il processo di pensiero mentre sviluppa il processo di analisi.

• Si può anche catturare il risultato come parte del notebook.

• Con l'aiuto dei taccuini jupyter, possiamo condividere il nostro lavoro anche con un collega.

Installazione ed esecuzione

Se stai usando la distribuzione Anaconda, non è necessario installare il notebook jupyter separatamente poiché è già installato con esso. Devi solo andare su Anaconda Prompt e digitare il seguente comando:

C:\>jupyter notebook

Dopo aver premuto Invio, avvierà un server notebook su localhost: 8888 del tuo computer. È mostrato nella seguente schermata:

Ora, dopo aver fatto clic sulla scheda Nuovo, otterrai un elenco di opzioni. Seleziona Python 3 e ti porterà al nuovo notebook per iniziare a lavorarci. Lo vedrai nelle seguenti schermate:

D'altra parte, se si utilizza la distribuzione Python standard, il notebook jupyter può essere installato utilizzando il popolare programma di installazione di pacchetti Python, pip.

pip install jupyter

Tipi di celle in Jupyter Notebook

I seguenti sono i tre tipi di celle in un quaderno jupyter:

Code cells- Come suggerisce il nome, possiamo usare queste celle per scrivere codice. Dopo aver scritto il codice / contenuto, lo invierà al kernel associato al notebook.

Markdown cells- Possiamo usare queste celle per annotare il processo di calcolo. Possono contenere elementi come testo, immagini, equazioni Latex, tag HTML ecc.

Raw cells- Il testo scritto in essi viene visualizzato così com'è. Queste celle servono fondamentalmente per aggiungere il testo che non desideriamo venga convertito dal meccanismo di conversione automatica di jupyter notebook.

Per uno studio più dettagliato del taccuino jupyter, puoi andare al linkhttps://www.tutorialspoint.com/jupyter/index.htm.

NumPy

È un altro componente utile che rende Python uno dei linguaggi preferiti per Data Science. Fondamentalmente sta per Numerical Python e consiste di oggetti array multidimensionali. Utilizzando NumPy, possiamo eseguire le seguenti importanti operazioni:

• Operazioni matematiche e logiche su array.

• Trasformazione di Fourier

• Operazioni associate all'algebra lineare.

Possiamo anche vedere NumPy come la sostituzione di MatLab perché NumPy viene utilizzato principalmente insieme a Scipy (Scientific Python) e Mat-plotlib (libreria di plottaggio).

Installation and Execution

Se stai utilizzando la distribuzione Anaconda, non è necessario installare NumPy separatamente poiché è già installato con esso. Devi solo importare il pacchetto nel tuo script Python con l'aiuto di quanto segue:

import numpy as np

D'altra parte, se si utilizza la distribuzione standard di Python, NumPy può essere installato utilizzando il popolare programma di installazione di pacchetti Python, pip.

pip install NumPy

Per uno studio più dettagliato di NumPy, puoi andare al linkhttps://www.tutorialspoint.com/numpy/index.htm.

Panda

È un'altra utile libreria Python che rende Python uno dei linguaggi preferiti per Data Science. Pandas è fondamentalmente utilizzato per la manipolazione dei dati, le discussioni e l'analisi. È stato sviluppato da Wes McKinney nel 2008. Con l'aiuto di Pandas, nell'elaborazione dei dati possiamo eseguire i seguenti cinque passaggi:

• Load

• Prepare

• Manipulate

• Model

• Analyze

Rappresentazione dei dati in Panda

L'intera rappresentazione dei dati in Panda viene eseguita con l'aiuto delle seguenti tre strutture di dati:

Series- È fondamentalmente un ndarray unidimensionale con un'etichetta dell'asse, il che significa che è come un semplice array con dati omogenei. Ad esempio, la serie seguente è una raccolta di numeri interi 1,5,10,15,24,25 ...

1

5

10

15

24

25

28

36

40

89

Data frame- È la struttura dati più utile e viene utilizzata per quasi tutti i tipi di rappresentazione e manipolazione dei dati nei panda. È fondamentalmente una struttura dati bidimensionale che può contenere dati eterogenei. In genere, i dati tabulari sono rappresentati utilizzando frame di dati. Ad esempio, la tabella seguente mostra i dati degli studenti con i loro nomi e numeri di ruolo, età e sesso -

Nome	Numero del rullino	Età	Genere
Aarav	1	15	Maschio
Harshit	2	14	Maschio
Kanika	3	16	Femmina
Mayank	4	15	Maschio

Panel- È una struttura dati tridimensionale contenente dati eterogenei. È molto difficile rappresentare il pannello in rappresentazione grafica, ma può essere illustrato come un contenitore di DataFrame.

La tabella seguente ci fornisce la dimensione e la descrizione delle strutture di dati sopra menzionate utilizzate in Panda -

Struttura dati	Dimensione	Descrizione
Serie	1-D	Dimensioni immutabili, dati 1-D omogenei
DataFrames	2-D	Dimensione Mutabile, dati eterogenei in forma tabulare
Pannello	3-D	Matrice modificabile in base alle dimensioni, contenitore di DataFrame.

Possiamo capire queste strutture di dati poiché la struttura di dati di dimensione superiore è il contenitore della struttura di dati di dimensione inferiore.

Installazione ed esecuzione

Se stai utilizzando la distribuzione Anaconda, non è necessario installare Pandas separatamente poiché è già installato con esso. Devi solo importare il pacchetto nel tuo script Python con l'aiuto di quanto segue:

import pandas as pd

D'altra parte, se si utilizza la distribuzione Python standard, è possibile installare Pandas utilizzando il popolare programma di installazione di pacchetti Python, pip.

pip install Pandas

Dopo aver installato Pandas, puoi importarlo nel tuo script Python come fatto sopra.

Esempio

Quello che segue è un esempio di creazione di una serie da ndarray utilizzando Pandas -

In [1]: import pandas as pd

In [2]: import numpy as np

In [3]: data = np.array(['g','a','u','r','a','v'])

In [4]: s = pd.Series(data)

In [5]: print (s)

0 g
1 a
2 u
3 r
4 a
5 v

dtype: object

Per uno studio più dettagliato dei Panda puoi andare al link https://www.tutorialspoint.com/python_pandas/index.htm.

Scikit-impara

Un'altra libreria python utile e più importante per la scienza dei dati e l'apprendimento automatico in Python è Scikit-learn. Le seguenti sono alcune caratteristiche di Scikit-learn che lo rendono così utile:

• È costruito su NumPy, SciPy e Matplotlib.

• È un open source e può essere riutilizzato con licenza BSD.

• È accessibile a tutti e può essere riutilizzato in vari contesti.

• Con l'aiuto di esso è possibile implementare un'ampia gamma di algoritmi di apprendimento automatico che coprono le principali aree del ML come la classificazione, il clustering, la regressione, la riduzione della dimensionalità, la selezione del modello ecc.

Installazione ed esecuzione

Se stai utilizzando la distribuzione Anaconda, non è necessario installare Scikit-learn separatamente poiché è già installato con essa. Devi solo usare il pacchetto nel tuo script Python. Ad esempio, con la seguente riga di script importiamo set di dati di pazienti con cancro al seno daScikit-learn -

from sklearn.datasets import load_breast_cancer

D'altra parte, se stai usando la distribuzione standard di Python e hai NumPy e SciPy, Scikit-learn può essere installato usando il popolare programma di installazione del pacchetto Python, pip.

pip install -U scikit-learn

Dopo aver installato Scikit-learn, puoi usarlo nel tuo script Python come hai fatto sopra.

Esistono vari algoritmi, tecniche e metodi di ML che possono essere utilizzati per creare modelli per la risoluzione di problemi della vita reale utilizzando i dati. In questo capitolo discuteremo di questi diversi tipi di metodi.

Diversi tipi di metodi

Di seguito sono riportati vari metodi ML basati su alcune ampie categorie:

Basato sulla supervisione umana

Nel processo di apprendimento, alcuni dei metodi basati sulla supervisione umana sono i seguenti:

Supervised Learning

Gli algoritmi oi metodi di apprendimento supervisionato sono gli algoritmi ML più comunemente utilizzati. Questo metodo o algoritmo di apprendimento prende il campione di dati, ovvero i dati di addestramento e il relativo output associato, ovvero etichette o risposte con ciascun campione di dati durante il processo di addestramento.

L'obiettivo principale degli algoritmi di apprendimento supervisionato è apprendere un'associazione tra campioni di dati di input e output corrispondenti dopo aver eseguito più istanze di dati di addestramento.

Ad esempio, abbiamo

x: variabili di input e

Y: variabile di output

Ora, applica un algoritmo per apprendere la funzione di mappatura dall'input all'output come segue:

Y = f (x)

Ora, l'obiettivo principale sarebbe approssimare la funzione di mappatura così bene che anche quando abbiamo nuovi dati di input (x), possiamo facilmente prevedere la variabile di output (Y) per quei nuovi dati di input.

Si chiama supervisionato perché l'intero processo di apprendimento può essere pensato mentre è supervisionato da un insegnante o supervisore. Esempi di algoritmi di apprendimento automatico supervisionato includonoDecision tree, Random Forest, KNN, Logistic Regression eccetera.

In base alle attività di ML, gli algoritmi di apprendimento supervisionato possono essere suddivisi in due grandi classi:

• Classification

• Regression

Classification

L'obiettivo principale delle attività basate sulla classificazione è prevedere le etichette di output categoriali o le risposte per i dati di input forniti. L'output sarà basato su quanto il modello ha appreso in fase di formazione. Come sappiamo, le risposte di output categoriali indicano valori non ordinati e discreti, quindi ogni risposta di output apparterrà a una classe o categoria specifica. Discuteremo anche la classificazione e gli algoritmi associati in dettaglio nei prossimi capitoli.

Regression

L'obiettivo principale delle attività basate sulla regressione è prevedere le etichette di output o le risposte che sono valori numerici continui, per i dati di input forniti. L'output sarà basato su ciò che il modello ha appreso nella sua fase di formazione. Fondamentalmente, i modelli di regressione utilizzano le caratteristiche dei dati di input (variabili indipendenti) ei loro corrispondenti valori numerici di output continui (variabili dipendenti o di risultato) per apprendere l'associazione specifica tra input e output corrispondenti. Discuteremo anche la regressione e gli algoritmi associati in dettaglio nei capitoli successivi.

Apprendimento senza supervisione

Come suggerisce il nome, è l'opposto dei metodi o degli algoritmi di ML supervisionati, il che significa che negli algoritmi di machine learning non supervisionati non abbiamo alcun supervisore che fornisca alcun tipo di guida. Gli algoritmi di apprendimento senza supervisione sono utili nello scenario in cui non abbiamo la libertà, come negli algoritmi di apprendimento supervisionato, di avere dati di addestramento pre-etichettati e vogliamo estrarre pattern utili dai dati di input.

Ad esempio, può essere inteso come segue:

Supponiamo di avere -

x: Input variables, quindi non ci sarebbe alcuna variabile di output corrispondente e gli algoritmi devono scoprire il modello interessante nei dati per l'apprendimento.

Esempi di algoritmi di apprendimento automatico non supervisionati includono il clustering K-means, K-nearest neighbors eccetera.

In base alle attività di ML, gli algoritmi di apprendimento senza supervisione possono essere suddivisi nelle seguenti ampie classi:

• Clustering

• Association

• Riduzione della dimensionalità

Clustering

I metodi di clustering sono uno dei metodi ML non supervisionati più utili. Questi algoritmi venivano utilizzati per trovare somiglianze e modelli di relazione tra campioni di dati e quindi raggruppare quei campioni in gruppi aventi somiglianza basata su caratteristiche. L'esempio reale di clustering è raggruppare i clienti in base al loro comportamento di acquisto.

Association

Un altro utile metodo ML senza supervisione è Associationche viene utilizzato per analizzare set di dati di grandi dimensioni per trovare modelli che rappresentano ulteriormente le relazioni interessanti tra i vari elementi. È anche definito comeAssociation Rule Mining o Market basket analysis che viene utilizzato principalmente per analizzare i modelli di acquisto dei clienti.

Dimensionality Reduction

Questo metodo ML senza supervisione viene utilizzato per ridurre il numero di variabili delle caratteristiche per ogni campione di dati selezionando un insieme di caratteristiche principali o rappresentative. Una domanda che sorge qui è: perché dobbiamo ridurre la dimensionalità? La ragione alla base è il problema della complessità dello spazio delle caratteristiche che sorge quando iniziamo ad analizzare ed estrarre milioni di caratteristiche da campioni di dati. Questo problema si riferisce generalmente alla "maledizione della dimensionalità". PCA (Principal Component Analysis), vicini K-più vicini e analisi discriminante sono alcuni degli algoritmi popolari per questo scopo.

Anomaly Detection

Questo metodo ML senza supervisione viene utilizzato per scoprire il verificarsi di eventi rari o osservazioni che generalmente non si verificano. Utilizzando le conoscenze acquisite, i metodi di rilevamento delle anomalie sarebbero in grado di distinguere tra punti dati anomali o normali. Alcuni degli algoritmi non supervisionati come il clustering, KNN può rilevare anomalie in base ai dati e alle loro caratteristiche.

Apprendimento semi-supervisionato

Questo tipo di algoritmi o metodi non sono né completamente supervisionati né completamente non supervisionati. Fondamentalmente rientrano tra i due metodi di apprendimento supervisionati e non supervisionati. Questi tipi di algoritmi utilizzano generalmente una piccola componente di apprendimento supervisionato, cioè una piccola quantità di dati annotati pre-etichettati e una grande componente di apprendimento non supervisionato, ovvero molti dati senza etichetta per l'addestramento. Possiamo seguire uno dei seguenti approcci per implementare metodi di apprendimento semi-supervisionati:

• Il primo e semplice approccio consiste nel costruire il modello supervisionato sulla base di una piccola quantità di dati etichettati e annotati e quindi costruire il modello non supervisionato applicando lo stesso a grandi quantità di dati non etichettati per ottenere più campioni etichettati. Ora, allena il modello su di loro e ripeti il ​​processo.

• , p> Il secondo approccio richiede alcuni sforzi extra. In questo approccio, possiamo prima utilizzare i metodi non supervisionati per raggruppare campioni di dati simili, annotare questi gruppi e quindi utilizzare una combinazione di queste informazioni per addestrare il modello.

Insegnamento rafforzativo

Questi metodi sono diversi dai metodi studiati in precedenza e anche usati molto raramente. In questo tipo di algoritmi di apprendimento, ci sarebbe un agente che vogliamo addestrare per un periodo di tempo in modo che possa interagire con un ambiente specifico. L'agente seguirà una serie di strategie per interagire con l'ambiente e poi, dopo aver osservato l'ambiente, intraprenderà azioni riguardanti lo stato attuale dell'ambiente. I seguenti sono i passaggi principali dei metodi di apprendimento per rinforzo:

• Step1 - Innanzitutto, dobbiamo preparare un agente con una serie iniziale di strategie.

• Step2 - Quindi osservare l'ambiente e il suo stato attuale.

• Step3 - Successivamente, selezionare la politica ottimale relativa allo stato attuale dell'ambiente ed eseguire un'azione importante.

• Step4 - Ora, l'agente può ottenere la corrispondente ricompensa o penalità in base all'azione intrapresa nel passaggio precedente.

• Step5 - Ora possiamo aggiornare le strategie se necessario.

• Step6 - Infine, ripetere i passaggi 2-5 finché l'agente non ha imparato e adotta le politiche ottimali.

Attività adatte al machine learning

Il diagramma seguente mostra il tipo di attività appropriato per vari problemi di ML:

Basato sulla capacità di apprendimento

Nel processo di apprendimento, i seguenti sono alcuni metodi basati sulla capacità di apprendimento:

Batch Learning

In molti casi, disponiamo di sistemi di machine learning end-to-end in cui dobbiamo addestrare il modello in una volta sola utilizzando tutti i dati di training disponibili. Questo tipo di metodo di apprendimento o algoritmo è chiamatoBatch or Offline learning. Si chiama apprendimento batch o offline perché è una procedura una tantum e il modello verrà addestrato con i dati in un unico batch. Di seguito sono riportati i passaggi principali dei metodi di apprendimento in batch:

Step1 - Innanzitutto, dobbiamo raccogliere tutti i dati di addestramento per iniziare ad addestrare il modello.

Step2 - Ora, inizia l'addestramento del modello fornendo tutti i dati di addestramento in una volta.

Step3 - Successivamente, interrompi il processo di apprendimento / formazione una volta ottenuti risultati / prestazioni soddisfacenti.

Step4- Infine, distribuisci questo modello addestrato nella produzione. Qui, predice l'output per un nuovo campione di dati.

Apprendimento online

È completamente opposto ai metodi di apprendimento batch o offline. In questi metodi di apprendimento, i dati di addestramento vengono forniti in più batch incrementali, chiamati mini-batch, all'algoritmo. I seguenti sono i passaggi principali dei metodi di apprendimento online:

Step1 - Innanzitutto, dobbiamo raccogliere tutti i dati di addestramento per iniziare l'addestramento del modello.

Step2 - Ora, avvia l'addestramento del modello fornendo un mini-batch di dati di addestramento all'algoritmo.

Step3 - Successivamente, dobbiamo fornire i mini-batch di dati di addestramento in più incrementi all'algoritmo.

Step4 - Poiché non si fermerà come l'apprendimento in batch, quindi dopo aver fornito interi dati di addestramento in mini-batch, fornire anche nuovi campioni di dati.

Step5 - Infine, continuerà ad apprendere per un periodo di tempo sulla base dei nuovi campioni di dati.

Basato sull'approccio di generalizzazione

Nel processo di apprendimento, i seguenti sono alcuni metodi basati su approcci di generalizzazione:

Apprendimento basato su istanze

Il metodo di apprendimento basato sull'istanza è uno dei metodi utili che costruiscono i modelli ML effettuando la generalizzazione basata sui dati di input. È l'opposto dei metodi di apprendimento studiati in precedenza nel modo in cui questo tipo di apprendimento coinvolge i sistemi ML, nonché i metodi che utilizzano i punti di dati grezzi stessi per disegnare i risultati per i campioni di dati più recenti senza costruire un modello esplicito sui dati di addestramento.

In parole semplici, l'apprendimento basato sull'istanza inizia fondamentalmente a funzionare guardando i punti dati di input e quindi utilizzando una metrica di somiglianza, generalizzerà e prevederà i nuovi punti dati.

Apprendimento basato su modelli

Nei metodi di apprendimento basati su modelli, viene eseguito un processo iterativo sui modelli ML che sono costruiti sulla base di vari parametri del modello, chiamati iperparametri e in cui i dati di input vengono utilizzati per estrarre le funzionalità. In questo apprendimento, gli iperparametri vengono ottimizzati sulla base di varie tecniche di convalida del modello. Questo è il motivo per cui possiamo affermare che i metodi di apprendimento basati su modelli utilizzano un approccio ML più tradizionale verso la generalizzazione.

Supponi di voler avviare un progetto ML, qual è la prima e più importante cosa di cui hai bisogno? Sono i dati che dobbiamo caricare per avviare qualsiasi progetto ML. Per quanto riguarda i dati, il formato più comune di dati per i progetti ML è CSV (valori separati da virgola).

Fondamentalmente, CSV è un semplice formato di file che viene utilizzato per memorizzare dati tabulari (numero e testo) come un foglio di calcolo in testo normale. In Python, possiamo caricare i dati CSV in modi diversi, ma prima di caricare i dati CSV dobbiamo fare attenzione ad alcune considerazioni.

Considerazioni durante il caricamento dei dati CSV

Il formato dati CSV è il formato più comune per i dati ML, ma dobbiamo fare attenzione a seguire le principali considerazioni durante il caricamento dello stesso nei nostri progetti ML -

Intestazione del file

Nei file di dati CSV, l'intestazione contiene le informazioni per ogni campo. Dobbiamo usare lo stesso delimitatore per il file di intestazione e per il file di dati perché è il file di intestazione che specifica come devono essere interpretati i campi di dati.

I seguenti sono i due casi relativi all'intestazione del file CSV che devono essere considerati:

• Case-I: When Data file is having a file header - Assegnerà automaticamente i nomi a ciascuna colonna di dati se il file di dati ha un'intestazione di file.

• Case-II: When Data file is not having a file header - Dobbiamo assegnare manualmente i nomi a ciascuna colonna di dati se il file di dati non ha un'intestazione di file.

In entrambi i casi, dobbiamo specificare esplicitamente se il nostro file CSV contiene un'intestazione o meno.

Commenti

I commenti in qualsiasi file di dati hanno il loro significato. Nel file di dati CSV, i commenti sono indicati da un cancelletto (#) all'inizio della riga. Dobbiamo considerare i commenti durante il caricamento dei dati CSV nei progetti ML perché se abbiamo commenti nel file, potrebbe essere necessario indicare, dipende dal metodo che scegliamo per il caricamento, se aspettarci quei commenti o meno.

Delimitatore

Nei file di dati CSV, il carattere virgola (,) è il delimitatore standard. Il ruolo del delimitatore è separare i valori nei campi. È importante considerare il ruolo del delimitatore durante il caricamento del file CSV nei progetti ML perché possiamo anche utilizzare un delimitatore diverso come una scheda o uno spazio vuoto. Ma nel caso di utilizzo di un delimitatore diverso da quello standard, dobbiamo specificarlo esplicitamente.

Citazioni

Nei file di dati CSV, le virgolette doppie ("") sono le virgolette predefinite. È importante considerare il ruolo delle virgolette durante il caricamento del file CSV nei progetti ML perché possiamo anche utilizzare virgolette diverse dalle virgolette doppie. Ma in caso di utilizzo di un carattere di citazione diverso da quello standard, dobbiamo specificarlo esplicitamente.

Metodi per caricare il file di dati CSV

Mentre si lavora con progetti ML, l'attività più cruciale è caricare correttamente i dati al suo interno. Il formato di dati più comune per i progetti ML è CSV ed è disponibile in vari gusti e diverse difficoltà di analisi. In questa sezione, discuteremo di tre approcci comuni in Python per caricare il file di dati CSV:

Carica CSV con la libreria standard Python

Il primo e più utilizzato approccio per caricare il file di dati CSV è l'uso della libreria standard Python che fornisce una varietà di moduli incorporati, ovvero il modulo csv e la funzione reader (). Il seguente è un esempio di caricamento di file di dati CSV con l'aiuto di esso:

Esempio

In questo esempio, stiamo usando il set di dati del fiore di iris che può essere scaricato nella nostra directory locale. Dopo aver caricato il file di dati, possiamo convertirlo in array NumPy e usarlo per progetti ML. Di seguito è riportato lo script Python per il caricamento del file di dati CSV -

Innanzitutto, dobbiamo importare il modulo csv fornito dalla libreria standard di Python come segue:

import csv

Successivamente, dobbiamo importare il modulo Numpy per convertire i dati caricati nell'array NumPy.

import numpy as np

Ora, fornisci il percorso completo del file, memorizzato nella nostra directory locale, con il file di dati CSV -

path = r"c:\iris.csv"

Quindi, usa la funzione csv.reader () per leggere i dati dal file CSV -

with open(path,'r') as f:
   reader = csv.reader(f,delimiter = ',')
   headers = next(reader)
   data = list(reader)
   data = np.array(data).astype(float)

Possiamo stampare i nomi delle intestazioni con la seguente riga di script:

print(headers)

La seguente riga di script stamperà la forma dei dati cioè il numero di righe e colonne nel file -

print(data.shape)

La prossima riga di script darà le prime tre righe di file di dati -

print(data[:3])

Output

['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
(150, 4)
[  [5.1 3.5 1.4 0.2]
   [4.9 3. 1.4 0.2]
   [4.7 3.2 1.3 0.2]]

Carica CSV con NumPy

Un altro approccio per caricare il file di dati CSV è la funzione NumPy e numpy.loadtxt (). Il seguente è un esempio di caricamento di file di dati CSV con l'aiuto di esso:

Esempio

In questo esempio, utilizziamo il set di dati Pima Indians contenente i dati dei pazienti diabetici. Questo set di dati è un set di dati numerico senza intestazione. Può anche essere scaricato nella nostra directory locale. Dopo aver caricato il file di dati, possiamo convertirlo in array NumPy e usarlo per progetti ML. Di seguito è riportato lo script Python per il caricamento del file di dati CSV -

from numpy import loadtxt
path = r"C:\pima-indians-diabetes.csv"
datapath= open(path, 'r')
data = loadtxt(datapath, delimiter=",")
print(data.shape)
print(data[:3])

Produzione

(768, 9)
[  [ 6. 148. 72. 35. 0. 33.6 0.627 50. 1.]
   [ 1. 85. 66. 29. 0. 26.6 0.351 31. 0.]
   [ 8. 183. 64. 0. 0. 23.3 0.672 32. 1.]]

Carica CSV con Panda

Un altro approccio per caricare il file di dati CSV è la funzione Pandas e pandas.read_csv (). Questa è la funzione molto flessibile che restituisce un pandas.DataFrame che può essere utilizzato immediatamente per la stampa. Il seguente è un esempio di caricamento di file di dati CSV con l'aiuto di esso:

Esempio

Qui, implementeremo due script Python, il primo è con il set di dati Iris con intestazioni e un altro è utilizzando il set di dati Pima Indians che è un set di dati numerico senza intestazione. Entrambi i set di dati possono essere scaricati nella directory locale.

Script-1

Di seguito è riportato lo script Python per il caricamento del file di dati CSV utilizzando Pandas on Iris Data set -

from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)
print(data[:3])

Output:

(150, 4)
   sepal_length   sepal_width  petal_length   petal_width
0         5.1     3.5          1.4            0.2
1         4.9     3.0          1.4            0.2
2         4.7     3.2          1.3            0.2

Script-2

Di seguito è riportato lo script Python per il caricamento del file di dati CSV, oltre a fornire anche i nomi delle intestazioni, utilizzando Pandas sul set di dati del diabete degli indiani Pima -

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.shape)
print(data[:3])

Output

(768, 9)
   preg  plas  pres   skin  test   mass    pedi    age   class
0   6    148    72      35    0     33.6   0.627    50      1
1   1    85     66      29    0     26.6   0.351    31      0
2   8    183    64      0     0     23.3   0.672    32      1

La differenza tra i tre approcci utilizzati sopra per caricare il file di dati CSV può essere facilmente compresa con l'aiuto degli esempi forniti.

introduzione

Mentre lavoriamo con progetti di machine learning, di solito ignoriamo due parti più importanti chiamate mathematics e data. È perché sappiamo che il ML è un approccio basato sui dati e il nostro modello ML produrrà solo risultati buoni o cattivi come i dati che gli abbiamo fornito.

Nel capitolo precedente, abbiamo discusso di come caricare i dati CSV nel nostro progetto ML, ma sarebbe bene comprendere i dati prima di caricarli. Possiamo comprendere i dati in due modi, con le statistiche e con la visualizzazione.

In questo capitolo, con l'aiuto di seguire le ricette di Python, comprenderemo i dati ML con le statistiche.

Guardando i dati grezzi

La prima ricetta è guardare i tuoi dati grezzi. È importante esaminare i dati grezzi perché le informazioni che otterremo dopo aver esaminato i dati grezzi aumenteranno le nostre possibilità di una migliore pre-elaborazione e gestione dei dati per i progetti ML.

Di seguito è riportato uno script Python implementato utilizzando la funzione head () di Pandas DataFrame sul set di dati del diabete degli indiani Pima per esaminare le prime 50 righe per comprenderlo meglio -

Esempio

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
print(data.head(50))

Produzione

preg   plas  pres    skin  test  mass   pedi    age      class
0      6      148     72     35   0     33.6    0.627    50    1
1      1       85     66     29   0     26.6    0.351    31    0
2      8      183     64      0   0     23.3    0.672    32    1
3      1       89     66     23  94     28.1    0.167    21    0
4      0      137     40     35  168    43.1    2.288    33    1
5      5      116     74      0   0     25.6    0.201    30    0
6      3       78     50     32   88    31.0    0.248    26    1
7     10      115      0      0   0     35.3    0.134    29    0
8      2      197     70     45  543    30.5    0.158    53    1
9      8      125     96      0   0     0.0     0.232    54    1
10     4      110     92      0   0     37.6    0.191    30    0
11    10      168     74      0   0     38.0    0.537    34    1
12    10      139     80      0   0     27.1    1.441    57    0
13     1      189     60     23  846    30.1    0.398    59    1
14     5      166     72     19  175    25.8    0.587    51    1
15     7      100      0      0   0     30.0    0.484    32    1
16     0      118     84     47  230    45.8    0.551    31    1
17     7      107     74      0   0     29.6    0.254    31    1
18     1      103     30     38  83     43.3    0.183    33    0
19     1      115     70     30  96     34.6    0.529    32    1
20     3      126     88     41  235    39.3    0.704    27    0
21     8       99     84      0   0     35.4    0.388    50    0
22     7      196     90      0   0     39.8    0.451    41    1
23     9      119     80     35   0     29.0    0.263    29    1
24    11      143     94     33  146    36.6    0.254    51    1
25    10      125     70     26  115    31.1    0.205    41    1
26     7      147     76      0   0     39.4    0.257    43    1
27     1       97     66     15  140    23.2    0.487    22    0
28    13      145     82     19  110    22.2    0.245    57    0
29     5      117     92      0   0     34.1    0.337    38    0
30     5      109     75     26   0     36.0    0.546    60    0
31     3      158     76     36  245    31.6    0.851    28    1
32     3       88     58     11   54    24.8    0.267    22    0
33     6       92     92      0   0     19.9    0.188    28    0
34    10      122     78     31   0     27.6    0.512    45    0
35     4      103     60     33  192    24.0    0.966    33    0
36    11      138     76      0   0     33.2    0.420    35    0
37     9      102     76     37   0     32.9    0.665    46    1
38     2       90     68     42   0     38.2    0.503    27    1
39     4      111     72     47  207    37.1    1.390    56    1
40     3      180     64     25   70    34.0    0.271    26    0
41     7      133     84      0   0     40.2    0.696    37    0
42     7      106     92     18   0     22.7    0.235    48    0
43     9      171    110     24  240    45.4    0.721    54    1
44     7      159     64      0   0     27.4    0.294    40    0
45     0      180     66     39   0     42.0    1.893    25    1
46     1      146     56      0   0     29.7    0.564    29    0
47     2       71     70     27   0     28.0    0.586    22    0
48     7      103     66     32   0     39.1    0.344    31    1
49     7      105      0      0   0     0.0     0.305    24    0

Possiamo osservare dall'output precedente che la prima colonna fornisce il numero di riga che può essere molto utile per fare riferimento a un'osservazione specifica.

Controllo delle dimensioni dei dati

È sempre una buona pratica sapere quanti dati, in termini di righe e colonne, abbiamo per il nostro progetto ML. Le ragioni alla base sono:

• Supponiamo che se abbiamo troppe righe e colonne, sarebbe necessario molto tempo per eseguire l'algoritmo e addestrare il modello.

• Supponiamo che se abbiamo troppo meno righe e colonne, allora non avremmo abbastanza dati per addestrare bene il modello.

Di seguito è riportato uno script Python implementato stampando la proprietà shape su Pandas Data Frame. Lo implementeremo sul set di dati iris per ottenere il numero totale di righe e colonne in esso.

Esempio

from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.shape)

Produzione

(150, 4)

Possiamo facilmente osservare dall'output che il set di dati iris, che useremo, ha 150 righe e 4 colonne.

Ottenere il tipo di dati di ogni attributo

Un'altra buona pratica è conoscere il tipo di dati di ogni attributo. Il motivo è che, in base al requisito, a volte potrebbe essere necessario convertire un tipo di dati in un altro. Ad esempio, potrebbe essere necessario convertire la stringa in virgola mobile o int per rappresentare valori categoriali o ordinali. Possiamo avere un'idea del tipo di dati dell'attributo guardando i dati grezzi, ma un altro modo è usare la proprietà dtypes di Pandas DataFrame. Con l'aiuto della proprietà dtypes possiamo classificare ogni tipo di dati degli attributi. Può essere compreso con l'aiuto del seguente script Python -

Esempio

from pandas import read_csv
path = r"C:\iris.csv"
data = read_csv(path)
print(data.dtypes)

Produzione

sepal_length float64
sepal_width float64
petal_length float64
petal_width float64
dtype: object

Dall'output di cui sopra, possiamo facilmente ottenere i tipi di dati di ogni attributo.

Riepilogo statistico dei dati

Abbiamo discusso la ricetta di Python per ottenere la forma, cioè il numero di righe e colonne, dei dati, ma molte volte abbiamo bisogno di rivedere i riepiloghi da quella forma di dati. Può essere fatto con l'aiuto della funzione description () di Pandas DataFrame che fornisce inoltre le seguenti 8 proprietà statistiche di ogni attributo di dati:

• Count

• Mean

• Deviazione standard

• Valore minimo

• Valore massimo

• 25%

• Mediana cioè 50%

• 75%

Esempio

from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
print(data.shape)
print(data.describe())

Produzione

(768, 9)
         preg      plas       pres      skin      test        mass       pedi      age      class
count 768.00      768.00    768.00     768.00    768.00     768.00     768.00    768.00    768.00
mean    3.85      120.89     69.11      20.54     79.80      31.99       0.47     33.24      0.35
std     3.37       31.97     19.36      15.95    115.24       7.88       0.33     11.76      0.48
min     0.00        0.00      0.00       0.00      0.00       0.00       0.08     21.00      0.00
25%     1.00       99.00     62.00       0.00      0.00      27.30       0.24     24.00      0.00
50%     3.00      117.00     72.00      23.00     30.50      32.00       0.37     29.00      0.00
75%     6.00      140.25     80.00      32.00    127.25      36.60       0.63     41.00      1.00
max    17.00      199.00    122.00      99.00    846.00      67.10       2.42     81.00      1.00

Dall'output di cui sopra, possiamo osservare il riepilogo statistico dei dati del set di dati Pima Indian Diabetes insieme alla forma dei dati.

Revisione della distribuzione delle classi

Le statistiche sulla distribuzione delle classi sono utili nei problemi di classificazione in cui è necessario conoscere l'equilibrio dei valori delle classi. È importante conoscere la distribuzione del valore della classe perché se abbiamo una distribuzione delle classi altamente sbilanciata, ovvero una classe sta avendo molte più osservazioni rispetto ad un'altra classe, potrebbe essere necessaria una gestione speciale nella fase di preparazione dei dati del nostro progetto ML. Possiamo facilmente ottenere la distribuzione delle classi in Python con l'aiuto di Pandas DataFrame.

Esempio

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
count_class = data.groupby('class').size()
print(count_class)

Produzione

Class
0 500
1 268
dtype: int64

Dall'output di cui sopra, si può vedere chiaramente che il numero di osservazioni con la classe 0 è quasi il doppio del numero di osservazioni con la classe 1.

Revisione della correlazione tra attributi

La relazione tra due variabili è chiamata correlazione. Nelle statistiche, il metodo più comune per calcolare la correlazione è il coefficiente di correlazione di Pearson. Può avere tre valori come segue:

• Coefficient value = 1 - Rappresenta il pieno positive correlazione tra variabili.

• Coefficient value = -1 - Rappresenta il pieno negative correlazione tra variabili.

• Coefficient value = 0 - Rappresenta no correlazione tra le variabili.

È sempre positivo per noi rivedere le correlazioni a coppie degli attributi nel nostro set di dati prima di utilizzarlo nel progetto ML perché alcuni algoritmi di apprendimento automatico come la regressione lineare e logistica funzioneranno male se abbiamo attributi altamente correlati. In Python, possiamo facilmente calcolare una matrice di correlazione degli attributi del set di dati con l'aiuto della funzione corr () su Pandas DataFrame.

Esempio

from pandas import read_csv
from pandas import set_option
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
set_option('display.width', 100)
set_option('precision', 2)
correlations = data.corr(method='pearson')
print(correlations)

Produzione

preg     plas     pres     skin     test      mass     pedi       age      class
preg     1.00     0.13     0.14     -0.08     -0.07   0.02     -0.03       0.54   0.22
plas     0.13     1.00     0.15     0.06       0.33   0.22      0.14       0.26   0.47
pres     0.14     0.15     1.00     0.21       0.09   0.28      0.04       0.24   0.07
skin    -0.08     0.06     0.21     1.00       0.44   0.39      0.18      -0.11   0.07
test    -0.07     0.33     0.09     0.44       1.00   0.20      0.19      -0.04   0.13
mass     0.02     0.22     0.28     0.39       0.20   1.00      0.14       0.04   0.29
pedi    -0.03     0.14     0.04     0.18       0.19   0.14      1.00       0.03   0.17
age      0.54     0.26     0.24     -0.11     -0.04   0.04      0.03       1.00   0.24
class    0.22     0.47     0.07     0.07       0.13   0.29      0.17       0.24   1.00

La matrice nell'output sopra fornisce la correlazione tra tutte le coppie dell'attributo nel set di dati.

Revisione dell'inclinazione della distribuzione degli attributi

L'asimmetria può essere definita come la distribuzione che si presume sia gaussiana ma che appare distorta o spostata in una direzione o nell'altra, o a sinistra oa destra. La revisione dell'asimmetria degli attributi è uno dei compiti importanti per i seguenti motivi:

• La presenza di asimmetria nei dati richiede la correzione in fase di preparazione dei dati in modo da poter ottenere una maggiore precisione dal nostro modello.

• La maggior parte degli algoritmi ML presume che i dati abbiano una distribuzione gaussiana, ovvero normale dei dati con curva a campana.

In Python, possiamo facilmente calcolare l'inclinazione di ogni attributo usando la funzione skew () su Pandas DataFrame.

Esempio

from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
print(data.skew())

Produzione

preg   0.90
plas   0.17
pres  -1.84
skin   0.11
test   2.27
mass  -0.43
pedi   1.92
age    1.13
class  0.64
dtype: float64

Dall'output di cui sopra, si può osservare un disallineamento positivo o negativo. Se il valore è più vicino a zero, mostra meno inclinazione.

introduzione

Nel capitolo precedente, abbiamo discusso l'importanza dei dati per gli algoritmi di Machine Learning insieme ad alcune ricette Python per comprendere i dati con le statistiche. C'è un altro modo chiamato Visualizzazione, per comprendere i dati.

Con l'aiuto della visualizzazione dei dati, possiamo vedere come appaiono i dati e che tipo di correlazione è tenuta dagli attributi dei dati. È il modo più veloce per vedere se le caratteristiche corrispondono all'output. Con l'aiuto di seguire le ricette di Python, possiamo comprendere i dati ML con le statistiche.

Grafici univariati: comprensione indipendente degli attributi

Il tipo più semplice di visualizzazione è la visualizzazione a variabile singola o "univariata". Con l'aiuto della visualizzazione univariata, possiamo comprendere ogni attributo del nostro set di dati in modo indipendente. Di seguito sono riportate alcune tecniche in Python per implementare la visualizzazione univariata:

Istogrammi

Gli istogrammi raggruppano i dati in contenitori ed è il modo più veloce per avere un'idea della distribuzione di ogni attributo nel set di dati. Di seguito sono riportate alcune delle caratteristiche degli istogrammi:

• Ci fornisce un conteggio del numero di osservazioni in ogni contenitore creato per la visualizzazione.

• Dalla forma del bidone, possiamo facilmente osservare la distribuzione, cioè il tempo è gaussiano, asimmetrico o esponenziale.

• Gli istogrammi ci aiutano anche a vedere possibili valori anomali.

Esempio

Il codice mostrato di seguito è un esempio di script Python che crea l'istogramma degli attributi del set di dati Pima Indian Diabetes. Qui, useremo la funzione hist () su Pandas DataFrame per generare istogrammi ematplotlib per averli tracciati.

from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.hist()
pyplot.show()

Produzione

L'output sopra mostra che ha creato l'istogramma per ogni attributo nel set di dati. Da questo, possiamo osservare che forse gli attributi età, pedi e test possono avere distribuzione esponenziale mentre massa e plas hanno distribuzione gaussiana.

Grafici di densità

Un'altra tecnica rapida e semplice per ottenere la distribuzione di ogni attributo è rappresentata dai grafici di densità. È anche come un istogramma ma ha una curva liscia disegnata attraverso la parte superiore di ogni contenitore. Possiamo chiamarli istogrammi astratti.

Esempio

Nell'esempio seguente, lo script Python genererà diagrammi di densità per la distribuzione degli attributi del set di dati di Pima Indian Diabetes.

from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='density', subplots=True, layout=(3,3), sharex=False)
pyplot.show()

Produzione

Dall'output di cui sopra, la differenza tra i grafici di densità e gli istogrammi può essere facilmente compresa.

Diagrammi Box e Whisker

I grafici Box e Whisker, chiamati anche boxplots in breve, sono un'altra tecnica utile per rivedere la distribuzione della distribuzione di ogni attributo. Le seguenti sono le caratteristiche di questa tecnica:

• È di natura univariata e riassume la distribuzione di ogni attributo.

• Traccia una linea per il valore medio, cioè per la mediana.

• Disegna una casella intorno al 25% e al 75%.

• Disegna anche baffi che ci daranno un'idea della diffusione dei dati.

• I punti all'esterno dei baffi indicano i valori anomali. I valori anomali sarebbero 1,5 volte maggiori della dimensione della diffusione dei dati centrali.

Esempio

Nell'esempio seguente, lo script Python genererà diagrammi di densità per la distribuzione degli attributi del set di dati di Pima Indian Diabetes.

from matplotlib import pyplot
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
data.plot(kind='box', subplots=True, layout=(3,3), sharex=False,sharey=False)
pyplot.show()

Produzione

Dal grafico sopra della distribuzione degli attributi, si può osservare che età, test e pelle appaiono distorti verso valori più piccoli.

Grafici multivariati: interazione tra più variabili

Un altro tipo di visualizzazione è la visualizzazione multivariabile o "multivariata". Con l'aiuto della visualizzazione multivariata, possiamo comprendere l'interazione tra più attributi del nostro set di dati. Di seguito sono riportate alcune tecniche in Python per implementare la visualizzazione multivariata:

Grafico a matrice di correlazione

La correlazione è un'indicazione sui cambiamenti tra due variabili. Nei nostri capitoli precedenti, abbiamo discusso i coefficienti di correlazione di Pearson e anche l'importanza della correlazione. Possiamo tracciare una matrice di correlazione per mostrare quale variabile ha una correlazione alta o bassa rispetto a un'altra variabile.

Esempio

Nell'esempio seguente, lo script Python genererà e traccerà una matrice di correlazione per il set di dati Pima Indian Diabetes. Può essere generato con l'aiuto della funzione corr () su Pandas DataFrame e tracciato con l'aiuto di pyplot.

from matplotlib import pyplot
from pandas import read_csv
import numpy
Path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(Path, names=names)
correlations = data.corr()
fig = pyplot.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(correlations, vmin=-1, vmax=1)
fig.colorbar(cax)
ticks = numpy.arange(0,9,1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(names)
ax.set_yticklabels(names)
pyplot.show()

Produzione

Dall'output precedente della matrice di correlazione, possiamo vedere che è simmetrico, ovvero l'angolo in basso a sinistra è lo stesso in alto a destra. Si osserva inoltre che ogni variabile è positivamente correlata tra loro.

Grafico a matrice a dispersione

I grafici a dispersione mostrano quanto una variabile è influenzata da un'altra o la relazione tra loro con l'aiuto di punti in due dimensioni. I grafici a dispersione sono molto simili ai grafici a linee nel concetto che utilizzano assi orizzontale e verticale per tracciare i punti dati.

Esempio

Nell'esempio seguente, lo script Python genererà e traccerà una matrice Scatter per il set di dati Pima Indian Diabetes. Può essere generato con l'aiuto della funzione scatter_matrix () su Pandas DataFrame e tracciato con l'aiuto di pyplot.

from matplotlib import pyplot
from pandas import read_csv
from pandas.tools.plotting import scatter_matrix
path = r"C:\pima-indians-diabetes.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=names)
scatter_matrix(data)
pyplot.show()

Produzione

introduzione

Gli algoritmi di Machine Learning dipendono completamente dai dati perché è l'aspetto più cruciale che rende possibile l'addestramento del modello. D'altra parte, se non saremo in grado di dare un senso a quei dati, prima di fornirli agli algoritmi di ML, una macchina sarà inutile. In parole semplici, abbiamo sempre bisogno di inserire i dati corretti, cioè i dati in scala, formato e caratteristiche significative corretti, per il problema che vogliamo che la macchina risolva.

Ciò rende la preparazione dei dati il ​​passaggio più importante nel processo ML. La preparazione dei dati può essere definita come la procedura che rende il nostro set di dati più appropriato per il processo di ML.

Perché la pre-elaborazione dei dati?

Dopo aver selezionato i dati grezzi per l'addestramento ML, l'attività più importante è la pre-elaborazione dei dati. In senso lato, la preelaborazione dei dati convertirà i dati selezionati in una forma con cui possiamo lavorare o che possiamo fornire agli algoritmi ML. Abbiamo sempre bisogno di preelaborare i nostri dati in modo che possano essere conformi alle aspettative dell'algoritmo di apprendimento automatico.

Tecniche di pre-elaborazione dei dati

Abbiamo le seguenti tecniche di pre-elaborazione dei dati che possono essere applicate al set di dati per produrre dati per algoritmi ML:

Ridimensionamento

Molto probabilmente il nostro set di dati comprende attributi con scala variabile, ma non siamo in grado di fornire tali dati all'algoritmo ML, quindi richiede il ridimensionamento. Il ridimensionamento dei dati garantisce che gli attributi siano sulla stessa scala. In genere, gli attributi vengono ridimensionati nell'intervallo 0 e 1. Gli algoritmi ML come la discesa del gradiente e k-Nearest Neighbors richiedono dati in scala. Possiamo riscalare i dati con l'aiuto della classe MinMaxScaler della libreria Python scikit-learn.

Esempio

In questo esempio riscaleremo i dati del set di dati del diabete degli indiani Pima che abbiamo usato in precedenza. Per prima cosa verranno caricati i dati CSV (come fatto nei capitoli precedenti) e poi con l'aiuto della classe MinMaxScaler, verranno riscalati nell'intervallo 0 e 1.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from pandas import read_csv
from numpy import set_printoptions
from sklearn import preprocessing
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Ora possiamo usare la classe MinMaxScaler per ridimensionare i dati nell'intervallo 0 e 1.

data_scaler = preprocessing.MinMaxScaler(feature_range=(0,1))
data_rescaled = data_scaler.fit_transform(array)

Possiamo anche riassumere i dati per l'output secondo la nostra scelta. Qui, stiamo impostando la precisione su 1 e mostriamo le prime 10 righe nell'output.

set_printoptions(precision=1)
print ("\nScaled data:\n", data_rescaled[0:10])

Produzione

Scaled data:
[[0.4 0.7 0.6 0.4 0. 0.5 0.2 0.5 1. ]
[0.1 0.4 0.5 0.3 0. 0.4 0.1 0.2 0. ]
[0.5 0.9 0.5 0. 0. 0.3 0.3 0.2 1. ]
[0.1 0.4 0.5 0.2 0.1 0.4 0. 0. 0. ]
[0. 0.7 0.3 0.4 0.2 0.6 0.9 0.2 1. ]
[0.3 0.6 0.6 0. 0. 0.4 0.1 0.2 0. ]
[0.2 0.4 0.4 0.3 0.1 0.5 0.1 0.1 1. ]
[0.6 0.6 0. 0. 0. 0.5 0. 0.1 0. ]
[0.1 1. 0.6 0.5 0.6 0.5 0. 0.5 1. ]
[0.5 0.6 0.8 0. 0. 0. 0.1 0.6 1. ]]

Dall'output precedente, tutti i dati sono stati ridimensionati nell'intervallo 0 e 1.

Normalizzazione

Un'altra tecnica utile per la pre-elaborazione dei dati è la normalizzazione. Questo viene utilizzato per ridimensionare ogni riga di dati in modo che abbia una lunghezza pari a 1. È utile principalmente nei dataset sparsi dove abbiamo molti zeri. Possiamo ridimensionare i dati con l'aiuto della classe Normalizer della libreria Python scikit-learn.

Tipi di normalizzazione

Nell'apprendimento automatico, ci sono due tipi di tecniche di pre-elaborazione della normalizzazione come segue:

Normalizzazione L1

Può essere definita come la tecnica di normalizzazione che modifica i valori del set di dati in modo tale che in ogni riga la somma dei valori assoluti sia sempre fino a 1. Viene anche chiamata Deviazione minima assoluta.

Example

In questo esempio, utilizziamo la tecnica di normalizzazione L1 per normalizzare i dati del set di dati del diabete degli indiani Pima che abbiamo utilizzato in precedenza. Innanzitutto, i dati CSV verranno caricati e quindi con l'aiuto della classe Normalizer verranno normalizzati.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

Ora possiamo usare la classe Normalizer con L1 per normalizzare i dati.

Data_normalizer = Normalizer(norm='l1').fit(array)
Data_normalized = Data_normalizer.transform(array)

Possiamo anche riassumere i dati per l'output secondo la nostra scelta. Qui, stiamo impostando la precisione su 2 e mostriamo le prime 3 righe nell'output.

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[[0.02 0.43 0.21 0.1 0. 0.1 0. 0.14 0. ]
[0. 0.36 0.28 0.12 0. 0.11 0. 0.13 0. ]
[0.03 0.59 0.21 0. 0. 0.07 0. 0.1 0. ]]

Normalizzazione L2

Può essere definita come la tecnica di normalizzazione che modifica i valori del set di dati in modo che in ogni riga la somma dei quadrati sia sempre fino a 1. Viene anche chiamata minimi quadrati.

Example

In questo esempio, utilizziamo la tecnica di normalizzazione L2 per normalizzare i dati del set di dati del diabete degli indiani Pima che abbiamo utilizzato in precedenza. Per prima cosa verranno caricati i dati CSV (come fatto nei capitoli precedenti) e poi con l'aiuto della classe Normalizer verranno normalizzati.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

Ora possiamo usare la classe Normalizer con L1 per normalizzare i dati.

Data_normalizer = Normalizer(norm='l2').fit(array)
Data_normalized = Data_normalizer.transform(array)

Possiamo anche riassumere i dati per l'output secondo la nostra scelta. Qui, stiamo impostando la precisione su 2 e mostriamo le prime 3 righe nell'output.

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[[0.03 0.83 0.4 0.2 0. 0.19 0. 0.28 0.01]
[0.01 0.72 0.56 0.24 0. 0.22 0. 0.26 0. ]
[0.04 0.92 0.32 0. 0. 0.12 0. 0.16 0.01]]

Binarizzazione

Come suggerisce il nome, questa è la tecnica con cui possiamo rendere i nostri dati binari. Possiamo usare una soglia binaria per rendere i nostri dati binari. I valori al di sopra di quel valore di soglia verranno convertiti in 1 e al di sotto di tale soglia verranno convertiti in 0. Ad esempio, se scegliamo il valore di soglia = 0,5, il valore del set di dati sopra di esso diventerà 1 e al di sotto diventerà 0. Ovvero perché possiamo chiamarlobinarizing i dati o thresholdingi dati. Questa tecnica è utile quando abbiamo probabilità nel nostro set di dati e vogliamo convertirle in valori nitidi.

Possiamo binarizzare i dati con l'aiuto della classe Binarizer della libreria Python scikit-learn.

Esempio

In questo esempio, ridimensioneremo i dati del set di dati del diabete degli indiani Pima che abbiamo utilizzato in precedenza. Innanzitutto, i dati CSV verranno caricati e quindi con l'aiuto della classe Binarizer verranno convertiti in valori binari, ovvero 0 e 1 a seconda del valore di soglia. Prendiamo 0,5 come valore di soglia.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from pandas import read_csv
from sklearn.preprocessing import Binarizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Ora possiamo usare la classe Binarize per convertire i dati in valori binari.

binarizer = Binarizer(threshold=0.5).fit(array)
Data_binarized = binarizer.transform(array)

Qui, stiamo mostrando le prime 5 righe nell'output.

print ("\nBinary data:\n", Data_binarized [0:5])

Produzione

Binary data:
[[1. 1. 1. 1. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 0. 1. 0. 1. 0.]
[1. 1. 1. 0. 0. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 0. 1. 0.]
[0. 1. 1. 1. 1. 1. 1. 1. 1.]]

Standardizzazione

Un'altra utile tecnica di pre-elaborazione dei dati che è fondamentalmente utilizzata per trasformare gli attributi dei dati con una distribuzione gaussiana. Differisce la media e la deviazione standard (deviazione standard) da una distribuzione gaussiana standard con una media di 0 e una deviazione standard di 1. Questa tecnica è utile negli algoritmi ML come la regressione lineare, la regressione logistica che presuppone una distribuzione gaussiana nel set di dati di input e produce una migliore risultati con dati riscalati. Possiamo standardizzare i dati (media = 0 e SD = 1) con l'aiuto della classe StandardScaler della libreria Python scikit-learn.

Esempio

In questo esempio, ridimensioneremo i dati del set di dati del diabete degli indiani Pima che abbiamo utilizzato in precedenza. Prima verranno caricati i dati CSV e poi con l'aiuto della classe StandardScaler verranno convertiti in distribuzione gaussiana con media = 0 e SD = 1.

Le prime righe del seguente script sono le stesse che abbiamo scritto nei capitoli precedenti durante il caricamento dei dati CSV.

from sklearn.preprocessing import StandardScaler
from pandas import read_csv
from numpy import set_printoptions
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Ora possiamo usare la classe StandardScaler per ridimensionare i dati.

data_scaler = StandardScaler().fit(array)
data_rescaled = data_scaler.transform(array)

Possiamo anche riassumere i dati per l'output secondo la nostra scelta. Qui stiamo impostando la precisione su 2 e mostriamo le prime 5 righe nell'output.

set_printoptions(precision=2)
print ("\nRescaled data:\n", data_rescaled [0:5])

Produzione

Rescaled data:
[[ 0.64 0.85 0.15 0.91 -0.69 0.2 0.47 1.43 1.37]
[-0.84 -1.12 -0.16 0.53 -0.69 -0.68 -0.37 -0.19 -0.73]
[ 1.23 1.94 -0.26 -1.29 -0.69 -1.1 0.6 -0.11 1.37]
[-0.84 -1. -0.16 0.15 0.12 -0.49 -0.92 -1.04 -0.73]
[-1.14 0.5 -1.5 0.91 0.77 1.41 5.48 -0.02 1.37]]

Etichettatura dei dati

Abbiamo discusso l'importanza di una buona fata per gli algoritmi di ML e di alcune tecniche per pre-elaborare i dati prima di inviarli agli algoritmi di ML. Un altro aspetto a questo riguardo è l'etichettatura dei dati. È anche molto importante inviare i dati ad algoritmi ML con un'etichettatura adeguata. Ad esempio, in caso di problemi di classificazione, sui dati sono presenti molte etichette sotto forma di parole, numeri, ecc.

Cos'è la codifica dell'etichetta?

La maggior parte delle funzioni sklearn prevede che i dati abbiano etichette numeriche anziché etichette di parole. Quindi, dobbiamo convertire tali etichette in etichette numeriche. Questo processo è chiamato codifica dell'etichetta. Possiamo eseguire la codifica delle etichette dei dati con l'aiuto della funzione LabelEncoder () della libreria Python scikit-learn.

Esempio

Nell'esempio seguente, lo script Python eseguirà la codifica dell'etichetta.

Innanzitutto, importa le librerie Python richieste come segue:

import numpy as np
from sklearn import preprocessing

Ora, dobbiamo fornire le etichette di input come segue:

input_labels = ['red','black','red','green','black','yellow','white']

La riga di codice successiva creerà il codificatore dell'etichetta e lo addestrerà.

encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)

Le successive righe di script controlleranno le prestazioni codificando l'elenco ordinato casuale -

test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
print("Encoded values =", list(encoded_values))
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)

Possiamo ottenere l'elenco dei valori codificati con l'aiuto del seguente script python -

print("\nEncoded values =", encoded_values)
print("\nDecoded labels =", list(decoded_list))

Produzione

Labels = ['green', 'red', 'black']
Encoded values = [1, 2, 0]
Encoded values = [3, 0, 4, 1]
Decoded labels = ['white', 'black', 'yellow', 'green']

Nel capitolo precedente abbiamo visto in dettaglio come preelaborare e preparare i dati per l'apprendimento automatico. In questo capitolo, comprendiamo in dettaglio la selezione delle caratteristiche dei dati e vari aspetti coinvolti in essa.

Importanza della selezione delle caratteristiche dei dati

Le prestazioni del modello di apprendimento automatico sono direttamente proporzionali alle funzionalità dei dati utilizzate per addestrarlo. Le prestazioni del modello ML saranno influenzate negativamente se le caratteristiche dei dati fornite sono irrilevanti. D'altra parte, l'uso di funzionalità dei dati rilevanti può aumentare la precisione del modello ML, in particolare la regressione lineare e logistica.

Ora sorge la domanda che cos'è la selezione automatica delle funzionalità? Può essere definito come il processo con l'aiuto del quale selezioniamo quelle caratteristiche nei nostri dati che sono più rilevanti per l'output o la variabile di previsione a cui siamo interessati. Viene anche chiamata selezione degli attributi.

Di seguito sono riportati alcuni dei vantaggi della selezione automatica delle caratteristiche prima della modellazione dei dati:

• L'esecuzione della selezione delle caratteristiche prima della modellazione dei dati ridurrà l'overfitting.

• L'esecuzione della selezione delle funzionalità prima della modellazione dei dati aumenterà la precisione del modello ML.

• L'esecuzione della selezione delle funzionalità prima della modellazione dei dati ridurrà il tempo di addestramento

Tecniche di selezione delle caratteristiche

Le seguenti sono tecniche di selezione automatica delle funzionalità che possiamo utilizzare per modellare i dati ML in Python:

Selezione univariata

Questa tecnica di selezione delle caratteristiche è molto utile nella selezione di quelle caratteristiche, con l'aiuto di test statistici, che hanno una relazione più forte con le variabili di previsione. Possiamo implementare una tecnica di selezione delle caratteristiche univariata con l'aiuto di SelectKBest0class della libreria Python scikit-learn.

Example

In questo esempio, utilizzeremo il set di dati Pima Indians Diabetes per selezionare 4 degli attributi con le migliori caratteristiche con l'aiuto del test statistico chi-quadrato.

from pandas import read_csv
from numpy import set_printoptions
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Successivamente, separeremo l'array in componenti di input e output -

X = array[:,0:8]
Y = array[:,8]

Le seguenti righe di codice selezioneranno le migliori funzionalità dal set di dati:

test = SelectKBest(score_func=chi2, k=4)
fit = test.fit(X,Y)

Possiamo anche riassumere i dati per l'output secondo la nostra scelta. Qui, stiamo impostando la precisione su 2 e mostriamo i 4 attributi dei dati con le migliori caratteristiche insieme al miglior punteggio di ogni attributo -

set_printoptions(precision=2)
print(fit.scores_)
featured_data = fit.transform(X)
print ("\nFeatured data:\n", featured_data[0:4])

Output

[ 111.52 1411.89 17.61 53.11 2175.57 127.67 5.39 181.3 ]
Featured data:
[[148. 0. 33.6 50. ]
[ 85. 0. 26.6 31. ]
[183. 0. 23.3 32. ]
[ 89. 94. 28.1 21. ]]

Eliminazione ricorsiva delle caratteristiche

Come suggerisce il nome, la tecnica di selezione delle feature RFE (Recursive feature elimination) rimuove gli attributi in modo ricorsivo e costruisce il modello con gli attributi rimanenti. Possiamo implementare la tecnica di selezione delle caratteristiche RFE con l'aiuto della classe RFE della libreria Python scikit-learn.

Esempio

In questo esempio, utilizzeremo RFE con algoritmo di regressione logistica per selezionare i 3 migliori attributi con le migliori caratteristiche dal set di dati del diabete degli indiani Pima a.

from pandas import read_csv
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Successivamente, separeremo l'array nei suoi componenti di input e output -

X = array[:,0:8]
Y = array[:,8]

Le seguenti righe di codice selezioneranno le migliori funzionalità da un set di dati:

model = LogisticRegression()
rfe = RFE(model, 3)
fit = rfe.fit(X, Y)
print("Number of Features: %d")
print("Selected Features: %s")
print("Feature Ranking: %s")

Produzione

Number of Features: 3
Selected Features: [ True False False False False True True False]
Feature Ranking: [1 2 3 5 6 1 1 4]

Possiamo vedere nell'output sopra, RFE sceglie preg, mass e pedi come le prime 3 migliori caratteristiche. Sono contrassegnati come 1 nell'output.

Analisi dei componenti principali (PCA)

La PCA, generalmente chiamata tecnica di riduzione dei dati, è una tecnica di selezione delle caratteristiche molto utile poiché utilizza l'algebra lineare per trasformare il set di dati in una forma compressa. Possiamo implementare la tecnica di selezione delle caratteristiche PCA con l'aiuto della classe PCA della libreria Python scikit-learn. Possiamo selezionare il numero di componenti principali nell'output.

Esempio

In questo esempio, utilizzeremo la PCA per selezionare i 3 migliori componenti principali dal set di dati del diabete degli indiani Pima.

from pandas import read_csv
from sklearn.decomposition import PCA
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Successivamente, separeremo l'array in componenti di input e output -

X = array[:,0:8]
Y = array[:,8]

Le seguenti righe di codice estrarranno le funzionalità dal set di dati:

pca = PCA(n_components=3)
fit = pca.fit(X)
print("Explained Variance: %s") % fit.explained_variance_ratio_
print(fit.components_)

Produzione

Explained Variance: [ 0.88854663 0.06159078 0.02579012]
[[ -2.02176587e-03 9.78115765e-02 1.60930503e-02 6.07566861e-02
9.93110844e-01 1.40108085e-02 5.37167919e-04 -3.56474430e-03]
[ 2.26488861e-02 9.72210040e-01 1.41909330e-01 -5.78614699e-02
-9.46266913e-02 4.69729766e-02 8.16804621e-04 1.40168181e-01]
[ -2.24649003e-02 1.43428710e-01 -9.22467192e-01 -3.07013055e-01
2.09773019e-02 -1.32444542e-01 -6.39983017e-04 -1.25454310e-01]]

Possiamo osservare dall'output di cui sopra che 3 componenti principali hanno poca somiglianza con i dati di origine.

Importanza delle caratteristiche

Come suggerisce il nome, la tecnica di importanza delle caratteristiche viene utilizzata per scegliere le caratteristiche di importanza. Fondamentalmente utilizza un classificatore supervisionato addestrato per selezionare le funzionalità. Possiamo implementare questa tecnica di selezione delle funzionalità con l'aiuto della classe ExtraTreeClassifier della libreria Python scikit-learn.

Esempio

In questo esempio, useremo ExtraTreeClassifier per selezionare le caratteristiche dal dataset di Pima Indians Diabetes.

from pandas import read_csv
from sklearn.ensemble import ExtraTreesClassifier
path = r'C:\Desktop\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(data, names=names)
array = dataframe.values

Successivamente, separeremo l'array in componenti di input e output -

X = array[:,0:8]
Y = array[:,8]

Le seguenti righe di codice estrarranno le funzionalità dal set di dati:

model = ExtraTreesClassifier()
model.fit(X, Y)
print(model.feature_importances_)

Produzione

[ 0.11070069 0.2213717 0.08824115 0.08068703 0.07281761 0.14548537 0.12654214 0.15415431]

Dall'output, possiamo osservare che ci sono punteggi per ogni attributo. Più alto è il punteggio, maggiore è l'importanza di quell'attributo.

Introduzione alla classificazione

La classificazione può essere definita come il processo di previsione della classe o della categoria dai valori osservati o dai punti dati forniti. L'output classificato può avere il formato "Nero" o "Bianco" o "spam" o "no spam".

Matematicamente, la classificazione è il compito di approssimare una funzione di mappatura (f) da variabili di input (X) a variabili di output (Y). Fondamentalmente appartiene all'apprendimento automatico supervisionato in cui vengono forniti anche gli obiettivi insieme al set di dati di input.

Un esempio di problema di classificazione può essere il rilevamento dello spam nelle e-mail. Possono esserci solo due categorie di output, "spam" e "no spam"; quindi questa è una classificazione di tipo binario.

Per implementare questa classificazione, dobbiamo prima addestrare il classificatore. In questo esempio, i messaggi di posta elettronica "spam" e "no spam" verranno utilizzati come dati di addestramento. Dopo aver addestrato con successo il classificatore, può essere utilizzato per rilevare un'e-mail sconosciuta.

Tipi di discenti nella classificazione

Abbiamo due tipi di studenti in relazione ai problemi di classificazione:

Studenti pigri

Come suggerisce il nome, questo tipo di discenti attende che i dati di test vengano visualizzati dopo aver memorizzato i dati di formazione. La classificazione viene eseguita solo dopo aver ottenuto i dati del test. Passano meno tempo all'addestramento ma più tempo alla previsione. Esempi di studenti pigri sono il vicino più prossimo K e il ragionamento basato sui casi.

Studenti desiderosi

Al contrario degli studenti pigri, gli studenti desiderosi costruiscono un modello di classificazione senza attendere che i dati di test vengano visualizzati dopo aver archiviato i dati di formazione. Dedicano più tempo all'addestramento ma meno tempo alla previsione. Esempi di studenti entusiasti sono gli alberi decisionali, i Naïve Bayes e le reti neurali artificiali (ANN).

Costruire un classificatore in Python

Scikit-learn, una libreria Python per l'apprendimento automatico, può essere utilizzata per creare un classificatore in Python. I passaggi per la creazione di un classificatore in Python sono i seguenti:

Passaggio 1: importazione del pacchetto Python necessario

Per creare un classificatore utilizzando scikit-learn, dobbiamo importarlo. Possiamo importarlo usando il seguente script:

import sklearn

Passaggio 2: importazione del set di dati

Dopo aver importato il pacchetto necessario, è necessario un set di dati per creare un modello di previsione della classificazione. Possiamo importarlo dal set di dati sklearn o utilizzarne un altro secondo le nostre esigenze. Utilizzeremo il database diagnostico del cancro al seno di sklearn Wisconsin. Possiamo importarlo con l'aiuto del seguente script:

from sklearn.datasets import load_breast_cancer

Il seguente script caricherà il set di dati;

data = load_breast_cancer()

Abbiamo anche bisogno di organizzare i dati e può essere fatto con l'aiuto dei seguenti script:

label_names = data['target_names']
   labels = data['target']
   feature_names = data['feature_names']
   features = data['data']

Il seguente comando stamperà il nome delle etichette, "maligno" e "benigno" nel caso del nostro database.

print(label_names)

L'output del comando precedente sono i nomi delle etichette -

['malignant' 'benign']

Queste etichette sono mappate ai valori binari 0 e 1. Malignant il cancro è rappresentato da 0 e Benign il cancro è rappresentato da 1.

I nomi delle caratteristiche e i valori delle caratteristiche di queste etichette possono essere visualizzati con l'aiuto dei seguenti comandi:

print(feature_names[0])

L'output del comando precedente sono i nomi delle funzionalità per l'etichetta 0, ad es Malignant cancro -

mean radius

Allo stesso modo, i nomi delle caratteristiche per l'etichetta possono essere prodotti come segue:

print(feature_names[1])

L'output del comando precedente sono i nomi delle funzionalità per l'etichetta 1, ad es Benign cancro -

mean texture

Possiamo stampare le caratteristiche per queste etichette con l'aiuto del seguente comando:

print(features[0])

Questo darà il seguente output:

[1.799e+01 1.038e+01 1.228e+02 1.001e+03 1.184e-01 2.776e-01 3.001e-01
1.471e-01 2.419e-01 7.871e-02 1.095e+00 9.053e-01 8.589e+00 1.534e+02
6.399e-03 4.904e-02 5.373e-02 1.587e-02 3.003e-02 6.193e-03 2.538e+01
1.733e+01 1.846e+02 2.019e+03 1.622e-01 6.656e-01 7.119e-01 2.654e-01
4.601e-01 1.189e-01]

Possiamo stampare le caratteristiche per queste etichette con l'aiuto del seguente comando:

print(features[1])

Questo darà il seguente output:

[2.057e+01 1.777e+01 1.329e+02 1.326e+03 8.474e-02 7.864e-02 8.690e-02
7.017e-02 1.812e-01 5.667e-02 5.435e-01 7.339e-01 3.398e+00 7.408e+01
5.225e-03 1.308e-02 1.860e-02 1.340e-02 1.389e-02 3.532e-03 2.499e+01
2.341e+01 1.588e+02 1.956e+03 1.238e-01 1.866e-01 2.416e-01 1.860e-01
2.750e-01 8.902e-02]

Passaggio 3: organizzazione dei dati in set di addestramento e test

Poiché dobbiamo testare il nostro modello su dati invisibili, divideremo il nostro set di dati in due parti: un set di addestramento e un set di test. Possiamo usare la funzione train_test_split () del pacchetto sklearn python per dividere i dati in insiemi. Il seguente comando importerà la funzione:

from sklearn.model_selection import train_test_split

Ora, il prossimo comando suddividerà i dati in dati di addestramento e test. In questo esempio, utilizziamo il 40% dei dati a scopo di test e il 60% dei dati a scopo di formazione -

train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)

Step4 - Valutazione del modello

Dopo aver diviso i dati in addestramento e test, è necessario creare il modello. A tale scopo utilizzeremo l'algoritmo Naïve Bayes. I seguenti comandi importeranno il modulo GaussianNB -

from sklearn.naive_bayes import GaussianNB

Ora inizializza il modello come segue:

gnb = GaussianNB()

Successivamente, con l'aiuto del seguente comando possiamo addestrare il modello:

model = gnb.fit(train, train_labels)

Ora, a scopo di valutazione, dobbiamo fare previsioni. Può essere fatto utilizzando la funzione predice () come segue:

preds = gnb.predict(test)
print(preds)

Questo darà il seguente output:

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0
1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0
1 1 1 1 1 1 0 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0
1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 1 0 0
1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0 0
0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1
0 0 1 1 0 1]

Le serie precedenti di 0 e 1 in output sono i valori previsti per Malignant e Benign classi di tumori.

Step5- Trovare l'accuratezza

Possiamo trovare l'accuratezza della costruzione del modello nel passaggio precedente confrontando i due array, ovvero test_labels e preds. Useremo la funzione accuratezza_score () per determinare l'accuratezza.

from sklearn.metrics import accuracy_score
   print(accuracy_score(test_labels,preds))
   0.951754385965

L'output sopra mostra che il classificatore NaïveBayes è accurato al 95,17%.

Metriche di valutazione della classificazione

Il lavoro non viene completato anche se è stata completata l'implementazione dell'applicazione o del modello di Machine Learning. Dobbiamo scoprire quanto è efficace il nostro modello? Possono esserci diverse metriche di valutazione, ma dobbiamo sceglierle con attenzione perché la scelta delle metriche influenza il modo in cui vengono misurate e confrontate le prestazioni di un algoritmo di apprendimento automatico.

Di seguito sono riportate alcune delle metriche di valutazione della classificazione importanti tra le quali è possibile scegliere in base al set di dati e al tipo di problema:

Matrice di confusione

È il modo più semplice per misurare le prestazioni di un problema di classificazione in cui l'output può essere di due o più tipi di classi. Una matrice di confusione non è altro che una tabella con due dimensioni. "Actual" e "Predicted" e inoltre, entrambe le dimensioni hanno "True Positives (TP)", "True Negatives (TN)", "False Positives (FP)", "False Negatives (FN)" come mostrato di seguito -

• True Positives (TP) - È il caso in cui sia la classe effettiva che la classe prevista del punto dati sono 1.

• True Negatives (TN) - È il caso in cui sia la classe effettiva che la classe prevista del punto dati sono 0.

• False Positives (FP) - È il caso in cui la classe effettiva del punto dati è 0 e la classe prevista del punto dati è 1.

• False Negatives (FN) - È il caso in cui la classe effettiva del punto dati è 1 e la classe prevista del punto dati è 0.

Possiamo trovare la matrice di confusione con l'aiuto della funzione confusion_matrix () di sklearn. Con l'aiuto del seguente script, possiamo trovare la matrice di confusione del classificatore binario costruito sopra -

from sklearn.metrics import confusion_matrix

Produzione

[[ 73 7]
[ 4 144]]

Precisione

Può essere definito come il numero di previsioni corrette fatte dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

$$=\frac{+}{+++}$$

Per il classificatore binario costruito sopra, TP + TN = 73 + 144 = 217 e TP + FP + FN + TN = 73 + 7 + 4 + 144 = 228.

Quindi, Precisione = 217/228 = 0,951754385965 che è lo stesso che abbiamo calcolato dopo aver creato il nostro classificatore binario.

Precisione

La precisione, utilizzata nel recupero dei documenti, può essere definita come il numero di documenti corretti restituiti dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

$$=\frac{}{+FP}$$

Per il classificatore binario costruito sopra, TP = 73 e TP + FP = 73 + 7 = 80.

Quindi, Precisione = 73/80 = 0,915

Richiamo o sensibilità

Il richiamo può essere definito come il numero di positivi restituiti dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

$$=\frac{}{+FN}$$

Per il classificatore binario costruito sopra, TP = 73 e TP + FN = 73 + 4 = 77.

Quindi, Precisione = 73/77 = 0,94805

Specificità

La specificità, a differenza del richiamo, può essere definita come il numero di negativi restituiti dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

$$=\frac{N}{N+FP}$$

Per il classificatore binario costruito sopra, TN = 144 e TN + FP = 144 + 7 = 151.

Quindi, Precisione = 144/151 = 0,95364

Vari algoritmi di classificazione ML

Di seguito sono riportati alcuni importanti algoritmi di classificazione ML:

• Regressione logistica

• Support Vector Machine (SVM)

• Albero decisionale

• Naïve Bayes

• Foresta casuale

Discuteremo tutti questi algoritmi di classificazione in dettaglio nei capitoli successivi.

Applicazioni

Alcune delle applicazioni più importanti degli algoritmi di classificazione sono le seguenti:

• Riconoscimento vocale

• Riconoscimento della grafia

• Identificazione biometrica

• Classificazione dei documenti

Introduzione alla regressione logistica

La regressione logistica è un algoritmo di classificazione dell'apprendimento supervisionato utilizzato per prevedere la probabilità di una variabile obiettivo. La natura dell'obiettivo o della variabile dipendente è dicotomica, il che significa che ci sarebbero solo due classi possibili.

In parole semplici, la variabile dipendente è di natura binaria con dati codificati come 1 (sta per successo / sì) o 0 (sta per fallimento / no).

Matematicamente, un modello di regressione logistica prevede P (Y = 1) in funzione di X. È uno degli algoritmi ML più semplici che può essere utilizzato per vari problemi di classificazione come il rilevamento dello spam, la previsione del diabete, il rilevamento del cancro, ecc.

Tipi di regressione logistica

In generale, regressione logistica significa regressione logistica binaria con variabili target binarie, ma possono esserci altre due categorie di variabili target che possono essere previste da essa. In base a quel numero di categorie, la regressione logistica può essere suddivisa nei seguenti tipi:

Binario o binomiale

In questo tipo di classificazione, una variabile dipendente avrà solo due tipi possibili, 1 e 0. Ad esempio, queste variabili possono rappresentare successo o fallimento, sì o no, vittoria o sconfitta ecc.

Multinomiale

In un tale tipo di classificazione, la variabile dipendente può avere 3 o più possibili tipi non ordinati o i tipi che non hanno significato quantitativo. Ad esempio, queste variabili possono rappresentare "Tipo A" o "Tipo B" o "Tipo C".

Ordinale

In un tale tipo di classificazione, la variabile dipendente può avere 3 o più tipi ordinati possibili o i tipi che hanno un significato quantitativo. Ad esempio, queste variabili possono rappresentare "scarso" o "buono", "molto buono", "eccellente" e ogni categoria può avere punteggi come 0,1,2,3.

Presupposti della regressione logistica

Prima di immergerci nell'implementazione della regressione logistica, dobbiamo essere consapevoli delle seguenti ipotesi sullo stesso:

• In caso di regressione logistica binaria, le variabili target devono essere sempre binarie e il risultato desiderato è rappresentato dal livello di fattore 1.

• Non dovrebbe esserci alcuna multi-collinearità nel modello, il che significa che le variabili indipendenti devono essere indipendenti l'una dall'altra.

• Dobbiamo includere variabili significative nel nostro modello.

• Dovremmo scegliere un campione di grandi dimensioni per la regressione logistica.

Modello di regressione logistica binaria

La forma più semplice di regressione logistica è la regressione logistica binomiale o binomiale in cui la variabile target o dipendente può avere solo 2 tipi possibili, 1 o 0. Ci consente di modellare una relazione tra più variabili predittive e una variabile target binomiale / binomiale. In caso di regressione logistica, la funzione lineare viene fondamentalmente utilizzata come input per un'altra funzione come nella seguente relazione:

$h_{\theta}{(x)}=g(\theta^{T}x)ℎ 0≤h_{\theta}≤1$

Ecco la funzione logistica o sigmoidea che può essere data come segue:

$g(z)= \frac{1}{1+e^{-z}}ℎ =\theta ^{T}$

La curva sigmoidea può essere rappresentata con l'aiuto del grafico seguente. Possiamo vedere i valori dell'asse y compreso tra 0 e 1 e incrocia l'asse a 0,5.

Le classi possono essere suddivise in positive o negative. L'output rientra nella probabilità di classe positiva se è compreso tra 0 e 1. Per la nostra implementazione, interpretiamo l'output della funzione di ipotesi come positivo se è ≥0,5, altrimenti negativo.

Abbiamo anche bisogno di definire una funzione di perdita per misurare il rendimento dell'algoritmo utilizzando i pesi sulle funzioni, rappresentati da theta come segue:

ℎ = ()

$J(\theta) = \frac{1}{m}.(-y^{T}log(h) - (1 -y)^Tlog(1-h))$

Ora, dopo aver definito la funzione di perdita, il nostro obiettivo principale è ridurre al minimo la funzione di perdita. Può essere fatto con l'aiuto del montaggio dei pesi, ovvero aumentando o diminuendo i pesi. Con l'aiuto di derivati ​​della funzione di perdita rispetto a ogni peso, saremmo in grado di sapere quali parametri dovrebbero avere un peso elevato e quali dovrebbero avere un peso minore.

La seguente equazione di discesa del gradiente ci dice come cambierebbe la perdita se modificassimo i parametri:

$\frac{()}{\theta_{j}}=\frac{1}{m}X^{T}(()−)$

Implementazione in Python

Ora implementeremo il concetto di cui sopra di regressione logistica binomiale in Python. A questo scopo, stiamo utilizzando un set di dati di fiori multivariato denominato "iris" che ha 3 classi di 50 istanze ciascuna, ma utilizzeremo le prime due colonne delle caratteristiche. Ogni classe rappresenta un tipo di fiore di iris.

Innanzitutto, dobbiamo importare le librerie necessarie come segue:

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets

Quindi, carica il set di dati iris come segue:

iris = datasets.load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1

Possiamo tracciare i nostri dati di allenamento come segue:

plt.figure(figsize=(6, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend();

Successivamente, definiremo la funzione sigmoide, la funzione di perdita e il gradiente discendente come segue:

class LogisticRegression:
   def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):
      self.lr = lr
      self.num_iter = num_iter
      self.fit_intercept = fit_intercept
      self.verbose = verbose
   def __add_intercept(self, X):
      intercept = np.ones((X.shape[0], 1))
      return np.concatenate((intercept, X), axis=1)
   def __sigmoid(self, z):
      return 1 / (1 + np.exp(-z))
   def __loss(self, h, y):
      return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
   def fit(self, X, y):
      if self.fit_intercept:
         X = self.__add_intercept(X)

Ora inizializza i pesi come segue:

self.theta = np.zeros(X.shape[1])
   for i in range(self.num_iter):
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      gradient = np.dot(X.T, (h - y)) / y.size
      self.theta -= self.lr * gradient
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      loss = self.__loss(h, y)
      if(self.verbose ==True and i % 10000 == 0):
         print(f'loss: {loss} \t')

Con l'aiuto del seguente script, possiamo prevedere le probabilità di output:

def predict_prob(self, X):
   if self.fit_intercept:
      X = self.__add_intercept(X)
   return self.__sigmoid(np.dot(X, self.theta))
def predict(self, X):
   return self.predict_prob(X).round()

Successivamente, possiamo valutare il modello e tracciarlo come segue:

model = LogisticRegression(lr=0.1, num_iter=300000)
preds = model.predict(X)
(preds == y).mean()

plt.figure(figsize=(10, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend()
x1_min, x1_max = X[:,0].min(), X[:,0].max(),
x2_min, x2_max = X[:,1].min(), X[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = model.predict_prob(grid).reshape(xx1.shape)
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='red');

Modello di regressione logistica multinomiale

Un'altra forma utile di regressione logistica è la regressione logistica multinomiale in cui la variabile target o dipendente può avere 3 o più possibili tipi non ordinati, ovvero i tipi che non hanno significato quantitativo.

Implementazione in Python

Ora implementeremo il concetto di cui sopra di regressione logistica multinomiale in Python. A tale scopo, stiamo utilizzando un set di dati da sklearn named digit.

Innanzitutto, dobbiamo importare le librerie necessarie come segue:

Import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_split

Successivamente, dobbiamo caricare il set di dati digit -

digits = datasets.load_digits()

Ora, definisci la matrice delle caratteristiche (X) e il vettore di risposta (y) come segue:

X = digits.data
y = digits.target

Con l'aiuto della riga di codice successiva, possiamo dividere X e y in set di addestramento e test -

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)

Ora crea un oggetto di regressione logistica come segue:

digreg = linear_model.LogisticRegression()

Ora, dobbiamo addestrare il modello utilizzando i set di addestramento come segue:

digreg.fit(X_train, y_train)

Quindi, fare le previsioni sul set di test come segue:

y_pred = digreg.predict(X_test)

Quindi stampare la precisione del modello come segue:

print("Accuracy of Logistic Regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)

Produzione

Accuracy of Logistic Regression model is: 95.6884561891516

Dall'output di cui sopra possiamo vedere la precisione del nostro modello è di circa il 96 percento.

Introduzione a SVM

Le Support Vector Machine (SVM) sono algoritmi di machine learning supervisionati potenti ma flessibili che vengono utilizzati sia per la classificazione che per la regressione. Ma generalmente vengono utilizzati nei problemi di classificazione. Negli anni '60, gli SVM furono introdotti per la prima volta ma in seguito furono perfezionati nel 1990. Gli SVM hanno il loro modo di implementazione unico rispetto ad altri algoritmi di apprendimento automatico. Ultimamente, sono estremamente popolari per la loro capacità di gestire più variabili continue e categoriali.

Funzionamento di SVM

Un modello SVM è fondamentalmente una rappresentazione di classi differenti in un iperpiano nello spazio multidimensionale. L'iperpiano verrà generato in modo iterativo da SVM in modo che l'errore possa essere ridotto al minimo. L'obiettivo di SVM è dividere i set di dati in classi per trovare un iperpiano marginale massimo (MMH).

I seguenti sono concetti importanti in SVM:

• Support Vectors- I punti dati più vicini all'iperpiano sono chiamati vettori di supporto. La linea di separazione verrà definita con l'aiuto di questi punti dati.

• Hyperplane - Come possiamo vedere nel diagramma sopra, è un piano o spazio decisionale che è diviso tra un insieme di oggetti aventi classi diverse.

• Margin- Può essere definito come il divario tra due linee sui punti dati dell'armadio di classi diverse. Può essere calcolata come la distanza perpendicolare dalla linea ai vettori di supporto. Un margine ampio è considerato un buon margine e un margine piccolo è considerato un margine negativo.

L'obiettivo principale di SVM è dividere i set di dati in classi per trovare un iperpiano marginale massimo (MMH) e può essere fatto nei due passaggi seguenti:

• Innanzitutto, SVM genererà iperpiani in modo iterativo che segrega le classi nel modo migliore.

• Quindi, sceglierà l'iperpiano che separa correttamente le classi.

Implementazione di SVM in Python

Per implementare SVM in Python inizieremo con l'importazione delle librerie standard come segue:

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import seaborn as sns; sns.set()

Successivamente, stiamo creando un set di dati di esempio, con dati separabili linearmente, da sklearn.dataset.sample_generator per la classificazione utilizzando SVM -

from sklearn.datasets.samples_generator import make_blobs
X, y = make_blobs(n_samples=100, centers=2,
      random_state=0, cluster_std=0.50)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

Il seguente sarebbe l'output dopo la generazione di un set di dati campione con 100 campioni e 2 cluster:

Sappiamo che SVM supporta la classificazione discriminante. divide le classi tra loro trovando semplicemente una linea nel caso di due dimensioni o collettore nel caso di più dimensioni. È implementato sul set di dati sopra come segue:

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
plt.plot([0.6], [2.1], 'x', color='black', markeredgewidth=4, markersize=12)
for m, b in [(1, 0.65), (0.5, 1.6), (-0.2, 2.9)]:
   plt.plot(xfit, m * xfit + b, '-k')
plt.xlim(-1, 3.5);

L'output è il seguente:

Possiamo vedere dall'output sopra che ci sono tre diversi separatori che discriminano perfettamente i campioni sopra.

Come discusso, l'obiettivo principale di SVM è dividere i set di dati in classi per trovare un iperpiano marginale massimo (MMH), quindi invece di tracciare una linea zero tra le classi, possiamo disegnare attorno a ciascuna linea un margine di una certa larghezza fino al punto più vicino. Può essere fatto come segue:

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
   for m, b, d in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]:
   yfit = m * xfit + b
   plt.plot(xfit, yfit, '-k')
   plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
         color='#AAAAAA', alpha=0.4)
plt.xlim(-1, 3.5);

Dall'immagine sopra in output, possiamo facilmente osservare i "margini" all'interno dei classificatori discriminanti. SVM sceglierà la linea che massimizza il margine.

Successivamente, utilizzeremo il classificatore di vettori di supporto di Scikit-Learn per addestrare un modello SVM su questi dati. Qui, stiamo usando il kernel lineare per adattare SVM come segue:

from sklearn.svm import SVC # "Support vector classifier"
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

L'output è il seguente:

SVC(C=10000000000.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
kernel='linear', max_iter=-1, probability=False, random_state=None,
shrinking=True, tol=0.001, verbose=False)

Ora, per una migliore comprensione, quanto segue traccerà le funzioni decisionali per SVC 2D:

def decision_function(model, ax=None, plot_support=True):
   if ax is None:
      ax = plt.gca()
   xlim = ax.get_xlim()
   ylim = ax.get_ylim()

Per valutare il modello, dobbiamo creare la griglia come segue:

x = np.linspace(xlim[0], xlim[1], 30)
y = np.linspace(ylim[0], ylim[1], 30)
Y, X = np.meshgrid(y, x)
xy = np.vstack([X.ravel(), Y.ravel()]).T
P = model.decision_function(xy).reshape(X.shape)

Successivamente, dobbiamo tracciare i confini e i margini delle decisioni come segue:

ax.contour(X, Y, P, colors='k',
   levels=[-1, 0, 1], alpha=0.5,
   linestyles=['--', '-', '--'])

Ora traccia in modo simile i vettori di supporto come segue:

if plot_support:
   ax.scatter(model.support_vectors_[:, 0],
      model.support_vectors_[:, 1],
      s=300, linewidth=1, facecolors='none');
ax.set_xlim(xlim)
ax.set_ylim(ylim)

Ora, usa questa funzione per adattare i nostri modelli come segue:

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
decision_function(model);

Possiamo osservare dall'output di cui sopra che un classificatore SVM si adatta ai dati con margini, cioè linee tratteggiate e vettori di supporto, gli elementi cardine di questo adattamento, toccando la linea tratteggiata. Questi punti del vettore di supporto sono memorizzati nell'attributo support_vectors_ del classificatore come segue:

model.support_vectors_

L'output è il seguente:

array([[0.5323772 , 3.31338909],
   [2.11114739, 3.57660449],
   [1.46870582, 1.86947425]])

Kernel SVM

In pratica, l'algoritmo SVM è implementato con il kernel che trasforma uno spazio dati di input nella forma richiesta. SVM utilizza una tecnica chiamata trucco del kernel in cui il kernel prende uno spazio di input di dimensioni ridotte e lo trasforma in uno spazio dimensionale superiore. In parole semplici, il kernel converte problemi non separabili in problemi separabili aggiungendovi più dimensioni. Rende SVM più potente, flessibile e preciso. I seguenti sono alcuni dei tipi di kernel usati da SVM:

Kernel lineare

Può essere utilizzato come prodotto scalare tra due osservazioni qualsiasi. La formula del kernel lineare è la seguente:

k (x, x _i ) = somma (x * x _i )

Dalla formula sopra, possiamo vedere che il prodotto tra due vettori dice & è la somma della moltiplicazione di ciascuna coppia di valori di input.

Kernel polinomiale

È una forma più generalizzata di kernel lineare e distingue lo spazio di input curvo o non lineare. Di seguito è riportata la formula per il kernel polinomiale:

K (x, xi) = 1 + somma (x * xi) ^ d

Qui d è il grado di polinomio, che dobbiamo specificare manualmente nell'algoritmo di apprendimento.

Kernel della funzione a base radiale (RBF)

Il kernel RBF, utilizzato principalmente nella classificazione SVM, mappa lo spazio di input in uno spazio dimensionale indefinito. La seguente formula lo spiega matematicamente:

K (x, xi) = exp (-gamma * sum ((x - xi ^ 2))

Qui, gamma varia da 0 a 1. Dobbiamo specificarlo manualmente nell'algoritmo di apprendimento. Un buon valore predefinito di gamma è 0,1.

Poiché abbiamo implementato SVM per dati separabili linearmente, possiamo implementarlo in Python per i dati che non sono separabili linearmente. Può essere fatto usando i kernel.

Esempio

Quello che segue è un esempio per la creazione di un classificatore SVM utilizzando i kernel. Useremo il set di dati iris di scikit-learn -

Inizieremo importando i seguenti pacchetti:

import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt

Ora, dobbiamo caricare i dati di input -

iris = datasets.load_iris()

Da questo set di dati, prendiamo le prime due funzionalità come segue:

X = iris.data[:, :2]
y = iris.target

Successivamente, tracceremo i confini SVM con i dati originali come segue:

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
   np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]

Ora, dobbiamo fornire il valore del parametro di regolarizzazione come segue:

C = 1.0

Successivamente, l'oggetto classificatore SVM può essere creato come segue:

Svc_classifier = svm.SVC (kernel = 'lineare', C = C) .fit (X, y)

Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize=(15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap=plt.cm.tab10, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('Support Vector Classifier with linear kernel')

Produzione

Text(0.5, 1.0, 'Support Vector Classifier with linear kernel')

Per creare un classificatore SVM con rbf kernel, possiamo cambiare il kernel in rbf come segue -

Svc_classifier = svm.SVC(kernel='rbf', gamma =‘auto’,C=C).fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize=(15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap=plt.cm.tab10, alpha=0.3)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('Support Vector Classifier with rbf kernel')

Produzione

Text(0.5, 1.0, 'Support Vector Classifier with rbf kernel')

Mettiamo il valore di gamma su "auto" ma puoi anche fornire il suo valore tra 0 e 1.

Pro e contro dei classificatori SVM

Pro dei classificatori SVM

I classificatori SVM offrono una grande precisione e funzionano bene con spazi ad alta dimensione. I classificatori SVM utilizzano fondamentalmente un sottoinsieme di punti di allenamento, quindi di conseguenza utilizza molto meno memoria.

Contro dei classificatori SVM

Hanno un tempo di formazione elevato, quindi in pratica non sono adatti per set di dati di grandi dimensioni. Un altro svantaggio è che i classificatori SVM non funzionano bene con classi sovrapposte.

Introduzione all'albero decisionale

In generale, l'analisi dell'albero decisionale è uno strumento di modellazione predittiva che può essere applicato a molte aree. Gli alberi decisionali possono essere costruiti mediante un approccio algoritmico in grado di suddividere il set di dati in modi diversi in base a condizioni diverse. Le decisioni tress sono gli algoritmi più potenti che rientrano nella categoria degli algoritmi supervisionati.

Possono essere utilizzati sia per attività di classificazione che di regressione. Le due entità principali di un albero sono i nodi decisionali, dove i dati vengono divisi e se ne vanno, dove abbiamo ottenuto il risultato. Di seguito viene fornito l'esempio di un albero binario per prevedere se una persona è in forma o inadatta fornendo varie informazioni come età, abitudini alimentari e abitudini di esercizio:

Nell'albero decisionale di cui sopra, le domande sono nodi decisionali e gli esiti finali sono foglie. Abbiamo i seguenti due tipi di alberi decisionali:

• Classification decision trees- In questo tipo di alberi decisionali, la variabile decisionale è categorica. L'albero decisionale sopra è un esempio di albero decisionale di classificazione.

• Regression decision trees - In questo tipo di alberi decisionali, la variabile decisionale è continua.

Implementazione dell'algoritmo dell'albero decisionale

Indice Gini

È il nome della funzione di costo utilizzata per valutare le suddivisioni binarie nel set di dati e funziona con la variabile di destinazione categoriale "Success" o "Failure".

Maggiore è il valore dell'indice di Gini, maggiore è l'omogeneità. Un valore di indice di Gini perfetto è 0 e il peggiore è 0,5 (per un problema di classe 2). L'indice di Gini per una divisione può essere calcolato con l'aiuto dei seguenti passaggi:

• Innanzitutto, calcola l'indice di Gini per i sotto-nodi utilizzando la formula p ^ 2 + q ^ 2, che è la somma del quadrato delle probabilità di successo e fallimento.

• Successivamente, calcola l'indice di Gini per la divisione utilizzando il punteggio Gini ponderato di ciascun nodo di quella divisione.

L'algoritmo CART (Classification and Regression Tree) utilizza il metodo Gini per generare divisioni binarie.

Creazione divisa

Una divisione fondamentalmente include un attributo nel set di dati e un valore. Possiamo creare una divisione nel set di dati con l'aiuto delle seguenti tre parti:

• Part1 - Calcolo del punteggio Gini: abbiamo appena discusso questa parte nella sezione precedente.

• Part2- Divisione di un set di dati: può essere definito come la separazione di un set di dati in due elenchi di righe aventi l'indice di un attributo e un valore di suddivisione di tale attributo. Dopo aver ottenuto i due gruppi - destro e sinistro, dal set di dati, possiamo calcolare il valore della divisione utilizzando il punteggio di Gini calcolato nella prima parte. Il valore di divisione deciderà in quale gruppo risiederà l'attributo.

• Part3- Valutazione di tutte le suddivisioni: la parte successiva dopo aver trovato il punteggio Gini e il set di dati di suddivisione è la valutazione di tutte le suddivisioni. A questo scopo, innanzitutto, dobbiamo controllare ogni valore associato a ciascun attributo come una suddivisione candidata. Quindi dobbiamo trovare la migliore divisione possibile valutando il costo della divisione. La migliore suddivisione verrà utilizzata come nodo nell'albero decisionale.

Costruire un albero

Come sappiamo che un albero ha nodo radice e nodi terminali. Dopo aver creato il nodo radice, possiamo costruire l'albero seguendo due parti:

Parte 1: creazione del nodo terminale

Durante la creazione dei nodi terminali dell'albero decisionale, un punto importante è decidere quando interrompere la crescita dell'albero o creare ulteriori nodi terminali. Può essere fatto utilizzando due criteri, ovvero la profondità massima dell'albero e i record minimi del nodo, come segue:

• Maximum Tree Depth- Come suggerisce il nome, questo è il numero massimo di nodi in un albero dopo il nodo radice. Dobbiamo smettere di aggiungere nodi terminali una volta che un albero ha raggiunto la massima profondità, cioè una volta che un albero ha ottenuto il numero massimo di nodi terminali.

• Minimum Node Records- Può essere definito come il numero minimo di modelli di addestramento di cui è responsabile un dato nodo. Dobbiamo smettere di aggiungere nodi terminali una volta che l'albero ha raggiunto questi record di nodo minimi o al di sotto di questo minimo.

Il nodo terminale viene utilizzato per fare una previsione finale.

Parte 2: suddivisione ricorsiva

Poiché abbiamo capito quando creare i nodi terminali, ora possiamo iniziare a costruire il nostro albero. La divisione ricorsiva è un metodo per costruire l'albero. In questo metodo, una volta creato un nodo, possiamo creare i nodi figli (nodi aggiunti a un nodo esistente) in modo ricorsivo su ogni gruppo di dati, generati dividendo il set di dati, chiamando la stessa funzione ancora e ancora.

Predizione

Dopo aver costruito un albero decisionale, dobbiamo fare una previsione al riguardo. Fondamentalmente, la previsione implica la navigazione dell'albero decisionale con la riga di dati specificatamente fornita.

Possiamo fare una previsione con l'aiuto della funzione ricorsiva, come fatto sopra. La stessa routine di previsione viene chiamata di nuovo con i nodi sinistro o figlio destro.

Presupposti

Di seguito sono riportati alcuni dei presupposti che facciamo durante la creazione dell'albero decisionale:

• Durante la preparazione degli alberi decisionali, il set di addestramento funge da nodo radice.

• Il classificatore dell'albero decisionale preferisce che i valori delle caratteristiche siano categoriali. Nel caso in cui si desideri utilizzare valori continui, devono essere discretizzati prima della creazione del modello.

• In base ai valori dell'attributo, i record vengono distribuiti in modo ricorsivo.

• Verrà utilizzato un approccio statistico per posizionare gli attributi in qualsiasi posizione del nodo, vale a dire il nodo radice o il nodo interno.

Implementazione in Python

Esempio

Nell'esempio seguente, implementeremo il classificatore dell'albero decisionale su Pima Indian Diabetes -

Innanzitutto, inizia con l'importazione dei pacchetti Python necessari -

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

Quindi, scarica il set di dati iris dal suo collegamento web come segue:

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
pima = pd.read_csv(r"C:\pima-indians-diabetes.csv", header=None, names=col_names)
pima.head()

pregnant    glucose  bp    skin  insulin  bmi   pedigree    age   label
0       6         148      72    35     0       33.6    0.627     50      1
1       1         85       66    29     0       26.6    0.351     31      0
2       8         183      64     0     0       23.3    0.672     32      1
3       1         89       66    23     94      28.1    0.167     21      0
4       0         137      40    35     168     43.1    2.288     33      1

Ora, dividi il set di dati in caratteristiche e variabile di destinazione come segue:

feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = pima[feature_cols] # Features
y = pima.label # Target variable

Successivamente, divideremo i dati in train e test split. Il codice seguente suddividerà il set di dati in 70% di dati di addestramento e 30% di dati di test -

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)

Quindi, addestrare il modello con l'aiuto della classe DecisionTreeClassifier di sklearn come segue:

clf = DecisionTreeClassifier()
clf = clf.fit(X_train,y_train)

Finalmente dobbiamo fare previsioni. Può essere fatto con l'aiuto del seguente script:

y_pred = clf.predict(X_test)

Successivamente, possiamo ottenere il punteggio di precisione, la matrice di confusione e il rapporto di classificazione come segue:

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Produzione

Confusion Matrix:
[[116 30]
[ 46 39]]
Classification Report:
            precision   recall   f1-score    support
      0       0.72      0.79       0.75     146
      1       0.57      0.46       0.51     85
micro avg     0.67      0.67       0.67     231
macro avg     0.64      0.63       0.63     231
weighted avg  0.66      0.67       0.66     231

Accuracy: 0.670995670995671

Visualizzazione dell'albero decisionale

L'albero decisionale sopra può essere visualizzato con l'aiuto del seguente codice:

from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
from IPython.display import Image
import pydotplus

dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,
      filled=True, rounded=True,
      special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('Pima_diabetes_Tree.png')
Image(graph.create_png())

Introduzione all'algoritmo di Naïve Bayes

Gli algoritmi di Bayes naïve sono una tecnica di classificazione basata sull'applicazione del teorema di Bayes con una forte ipotesi che tutti i predittori siano indipendenti l'uno dall'altro. In parole semplici, il presupposto è che la presenza di un elemento in una classe sia indipendente dalla presenza di qualsiasi altro elemento nella stessa classe. Ad esempio, un telefono può essere considerato intelligente se è dotato di touch screen, connessione Internet, buona fotocamera, ecc. Sebbene tutte queste funzioni dipendano l'una dall'altra, contribuiscono in modo indipendente alla probabilità che il telefono sia uno smartphone.

Nella classificazione bayesiana, l'interesse principale è trovare le probabilità a posteriori cioè la probabilità di un'etichetta date alcune caratteristiche osservate, (|). Con l'aiuto del teorema di Bayes, possiamo esprimerlo in forma quantitativa come segue:

$P(L |features)= \frac{P(L)P(features |L)}{()}$

Qui, (|) è la probabilità a posteriori di classe.

() è la probabilità a priori della classe.

(|) è la probabilità che è la probabilità del predittore data la classe.

() è la probabilità a priori del predittore.

Modello di costruzione utilizzando Naïve Bayes in Python

Libreria Python, Scikit learn è la libreria più utile che ci aiuta a costruire un modello Naïve Bayes in Python. Abbiamo i seguenti tre tipi di modello Naïve Bayes in Scikit impara la libreria Python:

Gaussian Naïve Bayes

È il più semplice classificatore Naïve Bayes che presume che i dati di ciascuna etichetta siano tratti da una semplice distribuzione gaussiana.

Naïve Bayes multinomiale

Un altro utile classificatore Naïve Bayes è Multinomial Naïve Bayes in cui si presume che le caratteristiche siano tratte da una semplice distribuzione multinomiale. Questo tipo di Naïve Bay è più appropriato per le caratteristiche che rappresentano i conteggi discreti.

Bernoulli Naïve Bayes

Un altro modello importante è Bernoulli Naïve Bayes in cui si presume che le caratteristiche siano binarie (0 e 1). La classificazione del testo con il modello "borsa di parole" può essere un'applicazione di Bernoulli Naïve Bayes.

Esempio

A seconda del nostro set di dati, possiamo scegliere uno qualsiasi dei modelli Naïve Bayes spiegati sopra. Qui stiamo implementando il modello Gaussian Naïve Bayes in Python -

Inizieremo con le importazioni richieste come segue:

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()

Ora, utilizzando la funzione make_blobs () di Scikit learn, possiamo generare blob di punti con distribuzione gaussiana come segue:

from sklearn.datasets import make_blobs
X, y = make_blobs(300, 2, centers=2, random_state=2, cluster_std=1.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

Successivamente, per utilizzare il modello GaussianNB, dobbiamo importare e creare il suo oggetto come segue:

from sklearn.naive_bayes import GaussianNB
model_GBN = GaussianNB()
model_GNB.fit(X, y);

Ora dobbiamo fare previsioni. Può essere fatto dopo aver generato alcuni nuovi dati come segue:

rng = np.random.RandomState(0)
Xnew = [-6, -14] + [14, 18] * rng.rand(2000, 2)
ynew = model_GNB.predict(Xnew)

Successivamente, stiamo tracciando nuovi dati per trovare i suoi confini -

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
lim = plt.axis()
plt.scatter(Xnew[:, 0], Xnew[:, 1], c=ynew, s=20, cmap='summer', alpha=0.1)
plt.axis(lim);

Ora, con l'aiuto della seguente riga di codici, possiamo trovare le probabilità a posteriori della prima e della seconda etichetta -

yprob = model_GNB.predict_proba(Xnew)
yprob[-10:].round(3)

Produzione

array([[0.998, 0.002],
      [1. , 0. ],
      [0.987, 0.013],
      [1. , 0. ],
      [1. , 0. ],
      [1. , 0. ],
      [1. , 0. ],
      [1. , 0. ],
      [0. , 1. ],
      [0.986, 0.014]])

Vantaggi svantaggi

Professionisti

I seguenti sono alcuni vantaggi dell'utilizzo dei classificatori Naïve Bayes:

• La classificazione Naïve Bayes è facile da implementare e veloce.

• Converrà più velocemente dei modelli discriminativi come la regressione logistica.

• Richiede meno dati di addestramento.

• È di natura altamente scalabile o scala linearmente con il numero di predittori e punti dati.

• Può fare previsioni probabilistiche e può gestire dati continui e discreti.

• L'algoritmo di classificazione Naïve Bayes può essere utilizzato sia per problemi di classificazione binaria che multi-classe.

Contro

I seguenti sono alcuni svantaggi dell'utilizzo dei classificatori Naïve Bayes:

• Uno degli svantaggi più importanti della classificazione Naïve Bayes è la sua forte indipendenza dalle caratteristiche perché nella vita reale è quasi impossibile avere un insieme di caratteristiche completamente indipendenti l'una dall'altra.

• Un altro problema con la classificazione Naïve Bayes è la sua "frequenza zero", il che significa che se una variabile categoriale ha una categoria ma non viene osservata nel set di dati di addestramento, il modello Naïve Bayes le assegnerà una probabilità zero e non sarà in grado di creare una predizione.

Applicazioni della classificazione Naïve Bayes

Le seguenti sono alcune applicazioni comuni della classificazione Naïve Bayes:

Real-time prediction - Grazie alla sua facilità di implementazione e al calcolo veloce, può essere utilizzato per fare previsioni in tempo reale.

Multi-class prediction - L'algoritmo di classificazione Naïve Bayes può essere utilizzato per prevedere la probabilità a posteriori di più classi di variabili target.

Text classification- A causa della caratteristica della predizione multi-classe, gli algoritmi di classificazione Naïve Bayes sono adatti per la classificazione del testo. Questo è il motivo per cui viene utilizzato anche per risolvere problemi come il filtro dello spam e l'analisi del sentiment.

Recommendation system - Insieme ad algoritmi come il filtraggio collaborativo, Naïve Bayes crea un sistema di Raccomandazione che può essere utilizzato per filtrare le informazioni invisibili e per prevedere il tempo che un utente vorrebbe o meno la risorsa data.

introduzione

La foresta casuale è un algoritmo di apprendimento supervisionato che viene utilizzato sia per la classificazione che per la regressione. Tuttavia, viene utilizzato principalmente per problemi di classificazione. Come sappiamo che una foresta è composta da alberi e più alberi significa foresta più robusta. Allo stesso modo, l'algoritmo di foresta casuale crea alberi decisionali su campioni di dati, quindi ottiene la previsione da ciascuno di essi e infine seleziona la soluzione migliore mediante il voto. È un metodo di insieme che è migliore di un singolo albero decisionale perché riduce l'over-fitting calcolando la media del risultato.

Utilizzo dell'algoritmo di foresta casuale

Possiamo capire il funzionamento dell'algoritmo Random Forest con l'aiuto dei seguenti passaggi:

Step1 - Innanzitutto, inizia con la selezione di campioni casuali da un dato set di dati.

Step2- Successivamente, questo algoritmo costruirà un albero decisionale per ogni campione. Quindi otterrà il risultato della previsione da ogni albero decisionale.

Step3 - In questa fase, verrà eseguita la votazione per ogni risultato previsto.

Step4 - Infine, seleziona il risultato della previsione più votato come risultato della previsione finale.

Il diagramma seguente ne illustrerà il funzionamento:

Implementazione in Python

Innanzitutto, inizia con l'importazione dei pacchetti Python necessari -

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

Quindi, scarica il set di dati iris dal suo collegamento web come segue:

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

Successivamente, dobbiamo assegnare i nomi delle colonne al set di dati come segue:

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

Ora, dobbiamo leggere il set di dati nel frame di dati dei panda come segue:

dataset = pd.read_csv(path, names=headernames)
dataset.head()

	sepalo-lunghezza	sepalo-larghezza	lunghezza dei petali	larghezza petalo	Classe
0	5.1	3.5	1.4	0.2	Iris-setosa
1	4.9	3.0	1.4	0.2	Iris-setosa
2	4.7	3.2	1.3	0.2	Iris-setosa
3	4.6	3.1	1.5	0.2	Iris-setosa
4	5.0	3.6	1.4	0.2	Iris-setosa

La pre-elaborazione dei dati verrà eseguita con l'aiuto delle seguenti righe di script:

X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values

Successivamente, divideremo i dati in train e test split. Il codice seguente suddividerà il set di dati in 70% di dati di addestramento e 30% di dati di test -

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)

Quindi, addestra il modello con l'aiuto della classe RandomForestClassifier di sklearn come segue:

from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators=50)
classifier.fit(X_train, y_train)

Infine, dobbiamo fare previsioni. Può essere fatto con l'aiuto del seguente script:

y_pred = classifier.predict(X_test)

Quindi, stampa i risultati come segue:

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Produzione

Confusion Matrix:
[[14 0 0]
[ 0 18 1]
[ 0 0 12]]
Classification Report:
               precision       recall     f1-score       support
Iris-setosa        1.00         1.00        1.00         14
Iris-versicolor    1.00         0.95        0.97         19
Iris-virginica     0.92         1.00        0.96         12
micro avg          0.98         0.98        0.98         45
macro avg          0.97         0.98        0.98         45
weighted avg       0.98         0.98        0.98         45

Accuracy: 0.9777777777777777

Pro e contro di Random Forest

Professionisti

I seguenti sono i vantaggi dell'algoritmo Random Forest:

• Supera il problema dell'overfitting calcolando la media o combinando i risultati di diversi alberi decisionali.

• Le foreste casuali funzionano bene per una vasta gamma di elementi di dati rispetto a un singolo albero decisionale.

• La foresta casuale ha una varianza inferiore rispetto a un singolo albero decisionale.

• Le foreste casuali sono molto flessibili e possiedono una precisione molto elevata.

• Il ridimensionamento dei dati non richiede un algoritmo di foresta casuale. Mantiene una buona precisione anche dopo aver fornito i dati senza ridimensionamento.

• Il ridimensionamento dei dati non richiede un algoritmo di foresta casuale. Mantiene una buona precisione anche dopo aver fornito i dati senza ridimensionamento.

Contro

I seguenti sono gli svantaggi dell'algoritmo Random Forest:

• La complessità è il principale svantaggio degli algoritmi di foresta casuale.

• La costruzione di foreste casuali è molto più difficile e richiede tempo rispetto agli alberi decisionali.

• Sono necessarie più risorse di calcolo per implementare l'algoritmo Random Forest.

• È meno intuitivo nel caso in cui disponiamo di un'ampia raccolta di alberi decisionali.

• Il processo di previsione che utilizza foreste casuali richiede molto tempo rispetto ad altri algoritmi.

Introduzione alla regressione

La regressione è un altro strumento statistico e di apprendimento automatico importante e ampiamente utilizzato. L'obiettivo principale delle attività basate sulla regressione è prevedere le etichette di output o le risposte che sono valori numerici continui, per i dati di input forniti. L'output sarà basato su quanto il modello ha appreso in fase di formazione. Fondamentalmente, i modelli di regressione utilizzano le caratteristiche dei dati di input (variabili indipendenti) ei loro corrispondenti valori numerici di output continui (variabili dipendenti o di risultato) per apprendere l'associazione specifica tra input e output corrispondenti.

Tipi di modelli di regressione

I modelli di regressione sono dei seguenti due tipi:

Simple regression model - Questo è il modello di regressione più elementare in cui le previsioni sono formate da una singola caratteristica univariata dei dati.

Multiple regression model - Come suggerisce il nome, in questo modello di regressione le previsioni sono formate da più caratteristiche dei dati.

Costruire un regressore in Python

Il modello di regressore in Python può essere costruito proprio come abbiamo costruito il classificatore. Scikit-learn, una libreria Python per l'apprendimento automatico, può essere utilizzata anche per creare un regressore in Python.

Nell'esempio seguente, costruiremo un modello di regressione di base che adatterà una linea ai dati, cioè un regressore lineare. I passaggi necessari per costruire un regressore in Python sono i seguenti:

Passaggio 1: importazione del pacchetto Python necessario

Per costruire un regressore usando scikit-learn, dobbiamo importarlo insieme ad altri pacchetti necessari. Possiamo importare il utilizzando il seguente script:

import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt

Passaggio 2: importazione del set di dati

Dopo aver importato il pacchetto necessario, è necessario un set di dati per creare un modello di previsione della regressione. Possiamo importarlo dal set di dati sklearn o utilizzarne un altro secondo le nostre esigenze. Useremo i nostri dati di input salvati. Possiamo importarlo con l'aiuto del seguente script:

input = r'C:\linear.txt'

Successivamente, dobbiamo caricare questi dati. Stiamo usando la funzione np.loadtxt per caricarlo.

input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]

Passaggio 3: organizzazione dei dati in set di addestramento e test

Dato che dobbiamo testare il nostro modello su dati invisibili, divideremo il nostro set di dati in due parti: un set di addestramento e un set di test. Il seguente comando lo eseguirà:

training_samples = int(0.6 * len(X))
testing_samples = len(X) - num_training

X_train, y_train = X[:training_samples], y[:training_samples]

X_test, y_test = X[training_samples:], y[training_samples:]

Step4- Valutazione e previsione del modello

Dopo aver diviso i dati in addestramento e test, è necessario creare il modello. A questo scopo useremo la funzione LineaRegression () di Scikit-learn. Il seguente comando creerà un oggetto regressore lineare.

reg_linear= linear_model.LinearRegression()

Quindi, addestra questo modello con gli esempi di addestramento come segue:

reg_linear.fit(X_train, y_train)

Ora, finalmente, dobbiamo fare la previsione con i dati del test.

y_test_pred = reg_linear.predict(X_test)

Step5- Traccia e visualizzazione

Dopo la previsione, possiamo tracciarla e visualizzarla con l'aiuto del seguente script:

plt.scatter(X_test, y_test, color='red')
plt.plot(X_test, y_test_pred, color='black', linewidth=2)
plt.xticks(())
plt.yticks(())
plt.show()

Produzione

Nell'output sopra, possiamo vedere la linea di regressione tra i punti dati.

Step6- Performance computation - Possiamo anche calcolare le prestazioni del nostro modello di regressione con l'aiuto di varie metriche delle prestazioni come segue:

print("Regressor model performance:")
print("Mean absolute error(MAE) =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error(MSE) =", round(sm.mean_squared_error(y_test, y_test_pred), 2))
print("Median absolute error =", round(sm.median_absolute_error(y_test, y_test_pred), 2))
print("Explain variance score =", round(sm.explained_variance_score(y_test, y_test_pred), 2))
print("R2 score =", round(sm.r2_score(y_test, y_test_pred), 2))

Produzione

Regressor model performance:
Mean absolute error(MAE) = 1.78
Mean squared error(MSE) = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09

Tipi di algoritmi di regressione ML

L'algoritmo di regressione ML più utile e popolare è l'algoritmo di regressione lineare che si divide ulteriormente in due tipi:

• Algoritmo di regressione lineare semplice

• Algoritmo di regressione lineare multipla.

Ne discuteremo e lo implementeremo in Python nel prossimo capitolo.

Applicazioni

Le applicazioni degli algoritmi di regressione ML sono le seguenti:

Forecasting or Predictive analysis- Uno degli usi importanti della regressione è la previsione o l'analisi predittiva. Ad esempio, possiamo prevedere il PIL, i prezzi del petrolio o in parole semplici i dati quantitativi che cambiano con il passare del tempo.

Optimization- Possiamo ottimizzare i processi aziendali con l'aiuto della regressione. Ad esempio, un gestore di un negozio può creare un modello statistico per comprendere l'ora in cui arrivano i clienti.

Error correction- Negli affari, prendere una decisione corretta è altrettanto importante dell'ottimizzazione del processo aziendale. La regressione può aiutarci a prendere la decisione corretta anche nel correggere la decisione già implementata.

Economics- È lo strumento più utilizzato in economia. Possiamo usare la regressione per prevedere l'offerta, la domanda, il consumo, l'investimento in scorte ecc.

Finance- Una società finanziaria è sempre interessata a ridurre al minimo il portafoglio di rischio e desidera conoscere i fattori che influiscono sui clienti. Tutto ciò può essere previsto con l'aiuto del modello di regressione.

Introduzione alla regressione lineare

La regressione lineare può essere definita come il modello statistico che analizza la relazione lineare tra una variabile dipendente con un dato insieme di variabili indipendenti. Relazione lineare tra variabili significa che quando il valore di una o più variabili indipendenti cambierà (aumento o diminuzione), anche il valore della variabile dipendente cambierà di conseguenza (aumento o diminuzione).

Matematicamente la relazione può essere rappresentata con l'aiuto della seguente equazione:

Y = mX + b

Qui, Y è la variabile dipendente che stiamo cercando di prevedere

X è la variabile dipendente che stiamo usando per fare previsioni.

m è lo slop della retta di regressione che rappresenta l'effetto che X ha su Y

b è una costante, nota come intercetta Y. Se X = 0, Y sarebbe uguale a b.

Inoltre, la relazione lineare può essere di natura positiva o negativa come spiegato di seguito -

Relazione lineare positiva

Una relazione lineare sarà chiamata positiva se aumentano sia la variabile indipendente che quella dipendente. Può essere compreso con l'aiuto del seguente grafico:

Relazione lineare negativa

Una relazione lineare sarà chiamata positiva se aumenti indipendenti e diminuzioni di variabili dipendenti. Può essere compreso con l'aiuto del seguente grafico:

Tipi di regressione lineare

La regressione lineare è dei seguenti due tipi:

• Regressione lineare semplice

• Regressione lineare multipla

Regressione lineare semplice (SLR)

È la versione più elementare della regressione lineare che prevede una risposta utilizzando una singola caratteristica. Il presupposto in SLR è che le due variabili siano correlate linearmente.

Implementazione di Python

Possiamo implementare SLR in Python in due modi, uno è fornire il proprio set di dati e l'altro è usare il set di dati dalla libreria python scikit-learn.

Example1 - Nel seguente esempio di implementazione di Python, stiamo usando il nostro set di dati.

Innanzitutto, inizieremo importando i pacchetti necessari come segue:

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

Quindi, definisci una funzione che calcolerà i valori importanti per SLR -

def coef_estimation(x, y):

La seguente riga di script fornirà il numero di osservazioni n -

n = np.size(x)

La media dei vettori x e y può essere calcolata come segue:

m_x, m_y = np.mean(x), np.mean(y)

Possiamo trovare la deviazione incrociata e la deviazione su x come segue:

SS_xy = np.sum(y*x) - n*m_y*m_x
SS_xx = np.sum(x*x) - n*m_x*m_x

Successivamente, i coefficienti di regressione cioè b possono essere calcolati come segue:

b_1 = SS_xy / SS_xx
b_0 = m_y - b_1*m_x
return(b_0, b_1)

Successivamente, dobbiamo definire una funzione che traccerà la linea di regressione e predirà il vettore di risposta -

def plot_regression_line(x, y, b):

La seguente riga di script traccerà i punti effettivi come grafico a dispersione:

plt.scatter(x, y, color = "m", marker = "o", s = 30)

La seguente riga di script predice il vettore di risposta:

y_pred = b[0] + b[1]*x

Le seguenti righe di script tracceranno la linea di regressione e vi metteranno le etichette:

plt.plot(x, y_pred, color = "g")
plt.xlabel('x')
plt.ylabel('y')
plt.show()

Alla fine, dobbiamo definire la funzione main () per fornire il set di dati e chiamare la funzione che abbiamo definito sopra -

def main():
   x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
   y = np.array([100, 300, 350, 500, 750, 800, 850, 900, 1050, 1250])
   b = coef_estimation(x, y)
   print("Estimated coefficients:\nb_0 = {} \nb_1 = {}".format(b[0], b[1]))
   plot_regression_line(x, y, b)
   
if __name__ == "__main__":
main()

Produzione

Estimated coefficients:
b_0 = 154.5454545454545
b_1 = 117.87878787878788

Example2 - Nel seguente esempio di implementazione di Python, stiamo usando il set di dati sul diabete da scikit-learn.

Innanzitutto, inizieremo importando i pacchetti necessari come segue:

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score

Successivamente, caricheremo il set di dati sul diabete e creeremo il suo oggetto -

diabetes = datasets.load_diabetes()

Poiché stiamo implementando SLR, utilizzeremo solo una funzione come segue:

X = diabetes.data[:, np.newaxis, 2]

Successivamente, dobbiamo suddividere i dati in set di addestramento e test come segue:

X_train = X[:-30]
X_test = X[-30:]

Successivamente, dobbiamo suddividere l'obiettivo in set di addestramento e test come segue:

y_train = diabetes.target[:-30]
y_test = diabetes.target[-30:]

Ora, per addestrare il modello dobbiamo creare un oggetto di regressione lineare come segue:

regr = linear_model.LinearRegression()

Quindi, addestrare il modello utilizzando i set di addestramento come segue:

regr.fit(X_train, y_train)

Quindi, fare previsioni utilizzando il set di test come segue:

y_pred = regr.predict(X_test)

Successivamente, stamperemo alcuni coefficienti come MSE, punteggio di varianza ecc. Come segue:

print('Coefficients: \n', regr.coef_)
print("Mean squared error: %.2f"
   % mean_squared_error(y_test, y_pred))
print('Variance score: %.2f' % r2_score(y_test, y_pred))

Ora traccia gli output come segue:

plt.scatter(X_test, y_test, color='blue')
plt.plot(X_test, y_pred, color='red', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

Produzione

Coefficients:
   [941.43097333]
Mean squared error: 3035.06
Variance score: 0.41

Regressione lineare multipla (MLR)

È l'estensione della regressione lineare semplice che prevede una risposta utilizzando due o più caratteristiche. Matematicamente possiamo spiegarlo come segue:

Considera un set di dati con n osservazioni, p caratteristiche cioè variabili indipendenti ey come una risposta cioè variabile dipendente la retta di regressione per p caratteristiche può essere calcolata come segue:

$h(x_{i})=b_{0}+b_{1}x_{i1}+b_{2}x_{i2}+...+b_{p}x_{ip}$

Qui, h (x _i ) è il valore di risposta previsto e b ₀ , b ₁ , b _{2 ...} , b _p sono i coefficienti di regressione.

I modelli di regressione lineare multipla includono sempre gli errori nei dati noti come errore residuo che modifica il calcolo come segue:

$h(x_{i})=b_{0}+b_{1}x_{i1}+b_{2}x_{i2}+...+b_{p}x_{ip}+e_{i}$

Possiamo anche scrivere l'equazione sopra come segue:

$y_{i}=h(x_{i})+e_{i}$ $e_{i}= y_{i} - h(x_{i})$

Implementazione di Python

in questo esempio, utilizzeremo il set di dati sull'alloggiamento di Boston da scikit learn -

Innanzitutto, inizieremo importando i pacchetti necessari come segue:

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, metrics

Quindi, carica il set di dati come segue:

boston = datasets.load_boston(return_X_y=False)

Le seguenti righe di script definiranno la matrice delle caratteristiche, X e il vettore di risposta, Y -

X = boston.data
y = boston.target

Successivamente, dividi il set di dati in set di addestramento e test come segue:

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.7, random_state=1)

Ora, crea un oggetto di regressione lineare e addestra il modello come segue:

reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)
print('Coefficients: \n', reg.coef_)
print('Variance score: {}'.format(reg.score(X_test, y_test)))
plt.style.use('fivethirtyeight')
plt.scatter(reg.predict(X_train), reg.predict(X_train) - y_train,
      color = "green", s = 10, label = 'Train data')
plt.scatter(reg.predict(X_test), reg.predict(X_test) - y_test,
      color = "blue", s = 10, label = 'Test data')
plt.hlines(y = 0, xmin = 0, xmax = 50, linewidth = 2)
plt.legend(loc = 'upper right')
plt.title("Residual errors")
plt.show()

Produzione

Coefficients:
[-1.16358797e-01 6.44549228e-02 1.65416147e-01 1.45101654e+00
-1.77862563e+01 2.80392779e+00 4.61905315e-02 -1.13518865e+00
3.31725870e-01 -1.01196059e-02 -9.94812678e-01 9.18522056e-03
-7.92395217e-01]
Variance score: 0.709454060230326

Presupposti

Di seguito sono riportate alcune ipotesi sul set di dati fatto dal modello di regressione lineare:

Multi-collinearity- Il modello di regressione lineare presuppone che nei dati vi sia una collinearità minima o nulla. Fondamentalmente, la multi-collinearità si verifica quando le variabili o le caratteristiche indipendenti hanno dipendenza da esse.

Auto-correlation- Un altro presupposto che il modello di regressione lineare assume è che nei dati vi sia pochissima o nessuna auto-correlazione. Fondamentalmente, l'auto-correlazione si verifica quando c'è dipendenza tra errori residui.

Relationship between variables - Il modello di regressione lineare presuppone che la relazione tra la risposta e le variabili delle caratteristiche debba essere lineare.

Introduzione al clustering

I metodi di clustering sono uno dei metodi ML non supervisionati più utili. Questi metodi vengono utilizzati per trovare la somiglianza così come i modelli di relazione tra i campioni di dati e quindi raggruppare quei campioni in gruppi aventi somiglianza basata sulle caratteristiche.

Il clustering è importante perché determina il raggruppamento intrinseco tra i dati presenti senza etichetta. Fondamentalmente fanno alcune ipotesi sui punti dati per costituire la loro somiglianza. Ciascuna ipotesi costruirà cluster diversi ma ugualmente validi.

Ad esempio, di seguito è riportato il diagramma che mostra il sistema di cluster raggruppato insieme il tipo simile di dati in diversi cluster:

Metodi di formazione dei cluster

Non è necessario che i cluster vengano formati in forma sferica. I seguenti sono alcuni altri metodi di formazione dei cluster:

Basato sulla densità

In questi metodi, i cluster si formano come la regione densa. Il vantaggio di questi metodi è che hanno una buona precisione e una buona capacità di unire due cluster. Ex. Clustering spaziale basato sulla densità di applicazioni con rumore (DBSCAN), punti di ordinazione per identificare la struttura di cluster (OTTICA) ecc.

Basato su base gerarchica

In questi metodi, i cluster sono formati come una struttura di tipo ad albero basata sulla gerarchia. Hanno due categorie: Agglomerativa (approccio dal basso verso l'alto) e Divisiva (approccio dall'alto verso il basso). Ex. Clustering using Representatives (CURE), Balanced iterative Reducing Clustering using Hierarchies (BETULLA) ecc.

Partizionamento

In questi metodi, i cluster vengono formati suddividendo gli oggetti in k cluster. Il numero di cluster sarà uguale al numero di partizioni. Ex. K-means, raggruppamento di applicazioni di grandi dimensioni basato sulla ricerca randomizzata (CLARANS).

Griglia

In questi metodi, i cluster sono formati come una struttura a griglia. Il vantaggio di questi metodi è che tutte le operazioni di clustering eseguite su queste griglie sono veloci e indipendenti dal numero di oggetti dati. Ex. Griglia di informazioni statistiche (STING), Clustering in Quest (CLIQUE).

Misurazione delle prestazioni del clustering

Una delle considerazioni più importanti riguardo al modello ML è valutare le sue prestazioni o si può dire la qualità del modello. In caso di algoritmi di apprendimento supervisionato, valutare la qualità del nostro modello è facile perché abbiamo già etichette per ogni esempio.

D'altra parte, in caso di algoritmi di apprendimento senza supervisione non siamo così fortunati perché abbiamo a che fare con dati senza etichetta. Ma abbiamo ancora alcune metriche che danno al professionista una panoramica sull'avvenimento del cambiamento nei cluster a seconda dell'algoritmo.

Prima di immergerci in profondità in tali metriche, dobbiamo capire che queste metriche valutano solo le prestazioni comparative dei modelli l'una rispetto all'altra piuttosto che misurare la validità della previsione del modello. Di seguito sono riportate alcune delle metriche che possiamo implementare sugli algoritmi di clustering per misurare la qualità del modello:

Analisi della silhouette

Analisi della silhouette utilizzata per verificare la qualità del modello di clustering misurando la distanza tra i cluster. Fondamentalmente ci fornisce un modo per valutare i parametri come il numero di cluster con l'aiuto diSilhouette score. Questo punteggio misura quanto è vicino ogni punto in un cluster ai punti nei cluster vicini.

Analisi del punteggio della silhouette

La gamma del punteggio di Silhouette è [-1, 1]. La sua analisi è la seguente:

• +1 Score - Vicino a +1 Silhouette score indica che il campione è lontano dal cluster adiacente.

• 0 Score - 0 Silhouette score indica che il campione si trova o è molto vicino al confine di decisione che separa due cluster vicini.

• -1 Score & meno -1 Silhouette score indica che i campioni sono stati assegnati ai cluster errati.

Il calcolo del punteggio Silhouette può essere effettuato utilizzando la seguente formula:

= (-) / (,)

Qui, = distanza media dai punti nel cluster più vicino

E, = distanza media intra-cluster da tutti i punti.

Indice Davis-Bouldin

L'indice DB è un'altra buona metrica per eseguire l'analisi degli algoritmi di clustering. Con l'aiuto dell'indice DB, possiamo comprendere i seguenti punti sul modello di clustering:

• Meteo che i cluster sono ben distanziati l'uno dall'altro o no?

• Quanto sono densi i grappoli?

Possiamo calcolare l'indice DB con l'aiuto della seguente formula:

$DB=\frac{1}{n}\displaystyle\sum\limits_{i=1}^n max_{j\neq{i}}\left(\frac{\sigma_{i}+\sigma_{j}}{d(c_{i},c_{j})}\right)$

Qui, = numero di cluster

σ _i = distanza media di tutti i punti del cluster dal centroide del cluster.

Meno l'indice DB, migliore è il modello di clustering.

Indice di Dunn

Funziona come l'indice DB ma ci sono i seguenti punti in cui entrambi differiscono:

• L'indice Dunn considera solo il caso peggiore ovvero i cluster vicini tra loro mentre l'indice DB considera la dispersione e la separazione di tutti i cluster nel modello di clustering.

• L'indice di Dunn aumenta all'aumentare delle prestazioni, mentre l'indice DB migliora quando i cluster sono ben distanziati e densi.

Possiamo calcolare l'indice di Dunn con l'aiuto della seguente formula:

$D=\frac{min_{1\leq i <{j}\leq{n}}P(i,j)}{mix_{1\leq i < k \leq n}q(k)}$

Qui, ,, = ogni indice per i cluster

= distanza tra i cluster

q = distanza intra-cluster

Tipi di algoritmi di clustering ML

I seguenti sono gli algoritmi di clustering ML più importanti e utili:

K-significa clustering

Questo algoritmo di clustering calcola i centroidi e itera finché non trova il centroide ottimale. Si presume che il numero di cluster sia già noto. È anche chiamato algoritmo di clustering piatto. Il numero di cluster identificati dai dati mediante algoritmo è rappresentato da "K" in K-mean.

Algoritmo di spostamento della media

È un altro potente algoritmo di clustering utilizzato nell'apprendimento senza supervisione. A differenza del clustering K-means, non fa alcuna supposizione, quindi è un algoritmo non parametrico.

Clustering gerarchico

È un altro algoritmo di apprendimento non supervisionato che viene utilizzato per raggruppare i punti dati senza etichetta con caratteristiche simili.

Discuteremo tutti questi algoritmi in dettaglio nei prossimi capitoli.

Applicazioni del clustering

Possiamo trovare il clustering utile nelle seguenti aree:

Data summarization and compression- Il clustering è ampiamente utilizzato nelle aree in cui è richiesta anche la sintesi, la compressione e la riduzione dei dati. Gli esempi sono l'elaborazione delle immagini e la quantizzazione vettoriale.

Collaborative systems and customer segmentation - Poiché il clustering può essere utilizzato per trovare prodotti simili o lo stesso tipo di utenti, può essere utilizzato nell'area dei sistemi collaborativi e della segmentazione della clientela.

Serve as a key intermediate step for other data mining tasks- L'analisi dei cluster può generare un riepilogo compatto dei dati per la classificazione, il test, la generazione di ipotesi; quindi, funge anche da passaggio intermedio chiave per altre attività di data mining.

Trend detection in dynamic data - Il clustering può essere utilizzato anche per il rilevamento delle tendenze nei dati dinamici creando vari cluster di tendenze simili.

Social network analysis- Il clustering può essere utilizzato nell'analisi dei social network. Gli esempi generano sequenze in immagini, video o audio.

Biological data analysis - Il clustering può essere utilizzato anche per creare gruppi di immagini, video quindi può essere utilizzato con successo nell'analisi dei dati biologici.

Introduzione all'algoritmo K-Means

L'algoritmo di clustering K-means calcola i centroidi e itera finché non trova il centroide ottimale. Si presume che il numero di cluster sia già noto. È anche chiamatoflat clusteringalgoritmo. Il numero di cluster identificati dai dati mediante algoritmo è rappresentato da "K" in K-mean.

In questo algoritmo, i punti dati vengono assegnati a un cluster in modo tale che la somma della distanza al quadrato tra i punti dati e il centroide sia minima. È chiaro che una minore variazione all'interno dei cluster porterà a punti dati più simili all'interno dello stesso cluster.

Lavorare con l'algoritmo K-Means

Possiamo comprendere il funzionamento dell'algoritmo di clustering K-Means con l'aiuto dei seguenti passaggi:

Step1 - Innanzitutto, dobbiamo specificare il numero di cluster, K, che devono essere generati da questo algoritmo.

Step2- Quindi, seleziona casualmente K punti dati e assegna ogni punto dati a un cluster. In parole semplici, classificare i dati in base al numero di punti dati.

Step3 - Ora calcolerà i centroidi dei cluster.

Step4 - Successivamente, continua a ripetere quanto segue finché non troviamo il centroide ottimale che è l'assegnazione dei punti dati ai cluster che non cambiano più -

4.1 - In primo luogo, verrà calcolata la somma della distanza al quadrato tra i punti dati e i centroidi.

4.2 - Ora, dobbiamo assegnare ogni punto dati al cluster più vicino di altri cluster (centroide).

4.3 - Infine calcola i centroidi per i cluster prendendo la media di tutti i punti dati di quel cluster.

Segue K-significa Expectation-Maximizationapproccio per risolvere il problema. Il passaggio Expectation viene utilizzato per assegnare i punti dati al cluster più vicino e il passaggio Maximization viene utilizzato per calcolare il centroide di ciascun cluster.

Mentre lavoriamo con l'algoritmo K-means dobbiamo occuparci delle seguenti cose:

• Mentre si lavora con algoritmi di clustering inclusi K-Means, si consiglia di standardizzare i dati perché tali algoritmi utilizzano la misurazione basata sulla distanza per determinare la somiglianza tra i punti dati.

• A causa della natura iterativa delle medie K e dell'inizializzazione casuale dei centroidi, le medie K possono rimanere in un ottimo locale e potrebbero non convergere all'ottimo globale. Questo è il motivo per cui si consiglia di utilizzare diverse inizializzazioni dei centroidi.

Implementazione in Python

I seguenti due esempi di implementazione dell'algoritmo di clustering K-Means ci aiuteranno a una migliore comprensione:

Esempio 1

È un semplice esempio per capire come funziona k-means. In questo esempio, genereremo prima un set di dati 2D contenente 4 diversi blob, dopodiché applicheremo l'algoritmo k-means per vedere il risultato.

Innanzitutto, inizieremo importando i pacchetti necessari:

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

Il codice seguente genererà il 2D, contenente quattro blob:

from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples=400, centers=4, cluster_std=0.60, random_state=0)

Successivamente, il codice seguente ci aiuterà a visualizzare il set di dati:

plt.scatter(X[:, 0], X[:, 1], s=20);
plt.show()

Quindi, crea un oggetto di KMeans oltre a fornire il numero di cluster, addestra il modello ed esegui la previsione come segue:

kmeans = KMeans(n_clusters=4)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)

Ora, con l'aiuto del seguente codice possiamo tracciare e visualizzare i centri del cluster selezionati dallo stimatore Python k-means -

plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=20, cmap='summer')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='blue', s=100, alpha=0.9);
plt.show()

Esempio 2

Passiamo a un altro esempio in cui applicheremo il clustering K-means su set di dati a cifre semplici. K-means tenterà di identificare cifre simili senza utilizzare le informazioni sull'etichetta originale.

Innanzitutto, inizieremo importando i pacchetti necessari:

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

Quindi, carica il set di dati delle cifre da sklearn e creane un oggetto. Possiamo anche trovare il numero di righe e colonne in questo set di dati come segue:

from sklearn.datasets import load_digits
digits = load_digits()
digits.data.shape

Produzione

(1797, 64)

L'output sopra mostra che questo set di dati ha 1797 campioni con 64 funzionalità.

Possiamo eseguire il raggruppamento come abbiamo fatto nell'esempio 1 sopra -

kmeans = KMeans(n_clusters=10, random_state=0)
clusters = kmeans.fit_predict(digits.data)
kmeans.cluster_centers_.shape

Produzione

(10, 64)

L'output sopra mostra che K-means ha creato 10 cluster con 64 funzionalità.

fig, ax = plt.subplots(2, 5, figsize=(8, 3))
centers = kmeans.cluster_centers_.reshape(10, 8, 8)
for axi, center in zip(ax.flat, centers):
   axi.set(xticks=[], yticks=[])
   axi.imshow(center, interpolation='nearest', cmap=plt.cm.binary)

Produzione

Come output, otterremo la seguente immagine che mostra i centri dei cluster appresi con k-means.

Le seguenti righe di codice faranno corrispondere le etichette del cluster apprese con le vere etichette trovate in esse -

from scipy.stats import mode
labels = np.zeros_like(clusters)
for i in range(10):
   mask = (clusters == i)
   labels[mask] = mode(digits.target[mask])[0]

Successivamente, possiamo verificare l'accuratezza come segue:

from sklearn.metrics import accuracy_score
accuracy_score(digits.target, labels)

Produzione

0.7935447968836951

L'output sopra mostra che la precisione è di circa l'80%.

Vantaggi e svantaggi

Vantaggi

Di seguito sono riportati alcuni vantaggi degli algoritmi di clustering K-Means:

• È molto facile da capire e implementare.

• Se disponiamo di un numero elevato di variabili, K-means sarebbe più veloce del clustering gerarchico.

• Durante il ricalcolo dei centroidi, un'istanza può modificare il cluster.

• I cluster più stretti sono formati con K-means rispetto al clustering gerarchico.

Svantaggi

I seguenti sono alcuni svantaggi degli algoritmi di clustering K-Means:

• È un po 'difficile prevedere il numero di cluster, ovvero il valore di k.

• L'output è fortemente influenzato dagli input iniziali come il numero di cluster (valore di k).

• L'ordine dei dati avrà un forte impatto sull'output finale.

• È molto sensibile al riscalaggio. Se ridimensioneremo i nostri dati mediante normalizzazione o standardizzazione, l'output cambierà completamente. Output finale.

• Non è bene eseguire il lavoro di raggruppamento se i cluster hanno una forma geometrica complicata.

Applicazioni dell'algoritmo di clustering K-Means

Gli obiettivi principali dell'analisi dei cluster sono:

• Per ottenere un'intuizione significativa dai dati con cui stiamo lavorando.

• Cluster-then-prevede dove verranno costruiti modelli diversi per sottogruppi diversi.

Per soddisfare gli obiettivi sopra menzionati, il clustering K-means sta funzionando abbastanza bene. Può essere utilizzato nelle seguenti applicazioni:

• Segmentazione del mercato

• Clustering dei documenti

• Segmentazione delle immagini

• Compressione dell'immagine

• Segmentazione della clientela

• Analisi dell'andamento sui dati dinamici

Introduzione all'algoritmo di spostamento della media

Come discusso in precedenza, è un altro potente algoritmo di clustering utilizzato nell'apprendimento non supervisionato. A differenza del clustering K-means, non fa alcuna ipotesi; quindi è un algoritmo non parametrico.

L'algoritmo di spostamento medio assegna fondamentalmente i punti dati ai cluster in modo iterativo spostando i punti verso la più alta densità di punti dati, cioè il centroide del cluster.

La differenza tra l'algoritmo K-Means e Mean-Shift è che in seguito non è necessario specificare il numero di cluster in anticipo perché il numero di cluster sarà determinato dall'algoritmo rispetto ai dati.

Lavorare con l'algoritmo di spostamento della media

Possiamo comprendere il funzionamento dell'algoritmo di clustering Mean-Shift con l'aiuto dei seguenti passaggi:

Step1 - Innanzitutto, inizia con i punti dati assegnati a un proprio cluster.

Step2 - Successivamente, questo algoritmo calcolerà i centroidi.

Step3 - In questo passaggio, verrà aggiornata la posizione dei nuovi centroidi.

Step4 - Ora, il processo verrà iterato e spostato nella regione a maggiore densità.

Step5 - Alla fine, verrà fermato una volta che i centroidi raggiungeranno una posizione da cui non può spostarsi ulteriormente.

Implementazione in Python

È un semplice esempio per capire come funziona l'algoritmo Mean-Shift. In questo esempio, genereremo prima un set di dati 2D contenente 4 diversi blob e successivamente applicheremo l'algoritmo Mean-Shift per vedere il risultato.

%matplotlib inline
import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")
from sklearn.datasets.samples_generator import make_blobs
centers = [[3,3,3],[4,5,5],[3,10,10]]
X, _ = make_blobs(n_samples = 700, centers = centers, cluster_std = 0.5)
plt.scatter(X[:,0],X[:,1])
plt.show()

ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
colors = 10*['r.','g.','b.','c.','k.','y.','m.']
for i in range(len(X)):
   plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 3)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
      marker=".",color='k', s=20, linewidths = 5, zorder=10)
plt.show()

Produzione

[[ 2.98462798 9.9733794 10.02629344]
[ 3.94758484 4.99122771 4.99349433]
[ 3.00788996 3.03851268 2.99183033]]
Estimated clusters: 3

Vantaggi e svantaggi

Vantaggi

Di seguito sono riportati alcuni vantaggi dell'algoritmo di clustering Mean-Shift:

• Non è necessario fare alcuna ipotesi di modello come nei mezzi K o nella miscela gaussiana.

• Può anche modellare i cluster complessi che hanno una forma non convessa.

• Ha bisogno solo di un parametro chiamato larghezza di banda che determina automaticamente il numero di cluster.

• Non c'è problema di minimi locali come in K-means.

• Nessun problema generato da valori anomali.

Svantaggi

Di seguito sono riportati alcuni svantaggi dell'algoritmo di clustering Mean-Shift:

L'algoritmo di spostamento medio non funziona bene in caso di dimensioni elevate, dove il numero di cluster cambia bruscamente.

• Non abbiamo alcun controllo diretto sul numero di cluster, ma in alcune applicazioni abbiamo bisogno di un numero specifico di cluster.

• Non può distinguere tra modalità significative e prive di significato.

Introduzione al clustering gerarchico

Il clustering gerarchico è un altro algoritmo di apprendimento non supervisionato che viene utilizzato per raggruppare i punti dati senza etichetta aventi caratteristiche simili. Gli algoritmi di clustering gerarchico rientrano nelle seguenti due categorie:

Agglomerative hierarchical algorithms- Negli algoritmi gerarchici agglomerativi, ogni punto dati viene trattato come un singolo cluster e quindi successivamente unire o agglomerare (approccio dal basso verso l'alto) le coppie di cluster. La gerarchia dei cluster è rappresentata come un dendrogramma o una struttura ad albero.

Divisive hierarchical algorithms - D'altra parte, negli algoritmi gerarchici divisivi, tutti i punti dati sono trattati come un grande cluster e il processo di clustering implica la divisione (approccio top-down) dell'unico grande cluster in vari piccoli cluster.

Passaggi per eseguire il clustering gerarchico agglomerativo

Spiegheremo il clustering Gerarchico più utilizzato e importante, ovvero l'agglomerato. I passaggi per eseguire lo stesso sono i seguenti:

Step1- Tratta ogni punto dati come un singolo cluster. Quindi, all'inizio avremo, diciamo K cluster. Anche il numero di punti dati sarà K all'inizio.

Step2- Ora, in questo passaggio dobbiamo formare un grande cluster unendo due datapoint dell'armadio. Ciò si tradurrà in un totale di cluster K-1.

Step3- Ora, per formare più cluster dobbiamo unire due cluster di armadio. Ciò si tradurrà in un totale di cluster K-2.

Step4 - Ora, per formare un grande cluster, ripetere i tre passaggi precedenti fino a quando K diventa 0, ovvero non sono rimasti più punti dati da unire.

Step5 - Alla fine, dopo aver creato un unico grande cluster, i dendrogrammi verranno utilizzati per suddividersi in più cluster a seconda del problema.

Ruolo dei dendrogrammi nel raggruppamento gerarchico agglomerativo

Come abbiamo discusso nell'ultimo passaggio, il ruolo del dendrogramma inizia una volta formato il grande ammasso. Dendrogram verrà utilizzato per dividere i cluster in più cluster di punti dati correlati a seconda del nostro problema. Può essere compreso con l'aiuto del seguente esempio:

Esempio 1

Per capire, iniziamo con l'importazione delle librerie richieste come segue:

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

Successivamente, tracceremo i punti dati che abbiamo preso per questo esempio:

X = np.array([[7,8],[12,20],[17,19],[26,15],[32,37],[87,75],[73,85], [62,80],[73,60],[87,96],])
labels = range(1, 11)
plt.figure(figsize=(10, 7))
plt.subplots_adjust(bottom=0.1)
plt.scatter(X[:,0],X[:,1], label='True Position')
for label, x, y in zip(labels, X[:, 0], X[:, 1]):
   plt.annotate(label,xy=(x, y), xytext=(-3, 3),textcoords='offset points', ha='right', va='bottom')
plt.show()

Dal diagramma sopra, è molto facile vedere che abbiamo due cluster in out datapoint, ma nei dati del mondo reale possono esserci migliaia di cluster. Successivamente, tracceremo i dendrogrammi dei nostri punti dati utilizzando la libreria Scipy -

from scipy.cluster.hierarchy import dendrogram, linkage
from matplotlib import pyplot as plt
linked = linkage(X, 'single')
labelList = range(1, 11)
plt.figure(figsize=(10, 7))
dendrogram(linked, orientation='top',labels=labelList, distance_sort='descending',show_leaf_counts=True)
plt.show()

Ora, una volta formato il grande ammasso, viene selezionata la distanza verticale più lunga. Viene quindi tracciata una linea verticale come mostrato nel diagramma seguente. Poiché la linea orizzontale attraversa la linea blu in due punti, il numero di cluster sarebbe due.

Successivamente, dobbiamo importare la classe per il clustering e chiamare il suo metodo fit_predict per prevedere il cluster. Stiamo importando la classe AgglomerativeClustering della libreria sklearn.cluster -

from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')
cluster.fit_predict(X)

Quindi, traccia il cluster con l'aiuto del seguente codice:

plt.scatter(X[:,0],X[:,1], c=cluster.labels_, cmap='rainbow')

Il diagramma sopra mostra i due cluster dai nostri datapoint.

Esempio 2

Poiché abbiamo compreso il concetto di dendrogrammi dal semplice esempio discusso sopra, passiamo a un altro esempio in cui stiamo creando cluster del punto dati nel set di dati del diabete indiano Pima utilizzando il clustering gerarchico:

import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
import numpy as np
from pandas import read_csv
path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]
data.shape
(768, 9)
data.head()

slno.	preg	Plas	Pres	pelle	test	massa	pedi	età	classe
0	6	148	72	35	0	33.6	0.627	50	1
1	1	85	66	29	0	26.6	0.351	31	0
2	8	183	64	0	0	23.3	0.672	32	1
3	1	89	66	23	94	28.1	0.167	21	0
4	0	137	40	35	168	43.1	2.288	33	1

patient_data = data.iloc[:, 3:5].values
import scipy.cluster.hierarchy as shc
plt.figure(figsize=(10, 7))
plt.title("Patient Dendograms")
dend = shc.dendrogram(shc.linkage(data, method='ward'))

from sklearn.cluster import AgglomerativeClustering
cluster = AgglomerativeClustering(n_clusters=4, affinity='euclidean', linkage='ward')
cluster.fit_predict(patient_data)
plt.figure(figsize=(10, 7))
plt.scatter(patient_data[:,0], patient_data[:,1], c=cluster.labels_, cmap='rainbow')

introduzione

L'algoritmo K-Nearest Neighbors (KNN) è un tipo di algoritmo ML supervisionato che può essere utilizzato sia per la classificazione che per i problemi predittivi di regressione. Tuttavia, viene utilizzato principalmente per la classificazione dei problemi predittivi nell'industria. Le seguenti due proprietà definirebbero bene KNN:

• Lazy learning algorithm - KNN è un algoritmo di apprendimento pigro perché non ha una fase di formazione specializzata e utilizza tutti i dati per l'addestramento durante la classificazione.

• Non-parametric learning algorithm - KNN è anche un algoritmo di apprendimento non parametrico perché non presuppone nulla sui dati sottostanti.

Funzionamento dell'algoritmo KNN

L'algoritmo K-Nearest Neighbors (KNN) utilizza la "somiglianza delle caratteristiche" per prevedere i valori dei nuovi punti dati, il che significa inoltre che al nuovo punto dati verrà assegnato un valore in base a quanto strettamente corrisponde ai punti nel set di addestramento. Possiamo capire il suo funzionamento con l'aiuto dei seguenti passaggi:

Step1- Per implementare qualsiasi algoritmo, abbiamo bisogno del set di dati. Quindi durante la prima fase di KNN, dobbiamo caricare i dati di addestramento e di test.

Step2- Successivamente, dobbiamo scegliere il valore di K cioè i punti dati più vicini. K può essere qualsiasi numero intero.

Step3 - Per ogni punto nei dati del test, eseguire le seguenti operazioni:

3.1- Calcola la distanza tra i dati del test e ogni riga di dati di allenamento con l'aiuto di uno qualsiasi dei metodi e cioè: distanza euclidea, Manhattan o Hamming. Il metodo più comunemente utilizzato per calcolare la distanza è euclideo.

3.2 - Ora, in base al valore della distanza, ordinali in ordine crescente.

3.3 - Successivamente, sceglierà le prime K righe dall'array ordinato.

3.4 - Ora assegnerà una classe al punto di test in base alla classe più frequente di queste righe.

Step4 - Fine

Esempio

Quello che segue è un esempio per comprendere il concetto di K e il funzionamento dell'algoritmo KNN -

Supponiamo di avere un set di dati che può essere tracciato come segue:

Ora, dobbiamo classificare il nuovo punto dati con punto nero (al punto 60,60) in classe blu o rossa. Assumiamo K = 3, cioè troverebbe tre punti dati più vicini. È mostrato nel diagramma successivo:

Possiamo vedere nel diagramma sopra i tre vicini più vicini al punto dati con punto nero. Tra questi tre, due di loro si trovano nella classe rossa, quindi il punto nero verrà assegnato anche nella classe rossa.

Implementazione in Python

Come sappiamo, l'algoritmo dei vicini più vicini (KNN) può essere utilizzato sia per la classificazione che per la regressione. Le seguenti sono le ricette in Python per utilizzare KNN come classificatore e come regressore:

KNN come classificatore

Innanzitutto, inizia con l'importazione dei pacchetti Python necessari -

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

Quindi, scarica il set di dati iris dal suo collegamento web come segue:

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

Successivamente, dobbiamo assegnare i nomi delle colonne al set di dati come segue:

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

Ora, dobbiamo leggere il set di dati nel frame di dati dei panda come segue:

dataset = pd.read_csv(path, names=headernames)
dataset.head()

slno.	sepalo-lunghezza	sepalo-larghezza	lunghezza dei petali	larghezza petalo	Classe
0	5.1	3.5	1.4	0.2	Iris-setosa
1	4.9	3.0	1.4	0.2	Iris-setosa
2	4.7	3.2	1.3	0.2	Iris-setosa
3	4.6	3.1	1.5	0.2	Iris-setosa
4	5.0	3.6	1.4	0.2	Iris-setosa

La pre-elaborazione dei dati verrà eseguita con l'aiuto delle seguenti righe di script:

X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values

Successivamente, divideremo i dati in train e test split. Il codice seguente dividerà il set di dati in 60% di dati di addestramento e 40% di dati di test -

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.40)

Successivamente, il ridimensionamento dei dati verrà eseguito come segue:

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Quindi, addestra il modello con l'aiuto della classe KNeighborsClassifier di sklearn come segue:

from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=8)
classifier.fit(X_train, y_train)

Finalmente dobbiamo fare previsioni. Può essere fatto con l'aiuto del seguente script:

y_pred = classifier.predict(X_test)

Quindi, stampa i risultati come segue:

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Produzione

Confusion Matrix:
[[21 0 0]
[ 0 16 0]
[ 0 7 16]]
Classification Report:
            precision      recall       f1-score       support
Iris-setosa       1.00        1.00         1.00          21
Iris-versicolor   0.70        1.00         0.82          16
Iris-virginica    1.00        0.70         0.82          23
micro avg         0.88        0.88         0.88          60
macro avg         0.90        0.90         0.88          60
weighted avg      0.92        0.88         0.88          60


Accuracy: 0.8833333333333333

KNN come regressore

Innanzitutto, inizia con l'importazione dei pacchetti Python necessari -

import numpy as np
import pandas as pd

Quindi, scarica il set di dati iris dal suo collegamento web come segue:

path = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

Successivamente, dobbiamo assegnare i nomi delle colonne al set di dati come segue:

headernames = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'Class']

Ora, dobbiamo leggere il set di dati nel frame di dati dei panda come segue:

data = pd.read_csv(url, names=headernames)
array = data.values
X = array[:,:2]
Y = array[:,2]
data.shape

output:(150, 5)

Quindi, importa KNeighborsRegressor da sklearn per adattarlo al modello -

from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=10)
knnr.fit(X, y)

Alla fine, possiamo trovare l'MSE come segue:

print ("The MSE is:",format(np.power(y-knnr.predict(X),2).mean()))

Produzione

The MSE is: 0.12226666666666669

Pro e contro di KNN

Professionisti

• È un algoritmo molto semplice da capire e interpretare.

• È molto utile per i dati non lineari perché non ci sono ipotesi sui dati in questo algoritmo.

• È un algoritmo versatile in quanto possiamo usarlo per la classificazione e per la regressione.

• Ha un'accuratezza relativamente alta ma ci sono modelli di apprendimento supervisionato molto migliori di KNN.

Contro

• È un algoritmo computazionalmente un po 'costoso perché memorizza tutti i dati di addestramento.

• Elevata memoria richiesta rispetto ad altri algoritmi di apprendimento supervisionato.

• La previsione è lenta in caso di grande N.

• È molto sensibile alla scala dei dati e alle caratteristiche irrilevanti.

Applicazioni di KNN

Di seguito sono riportate alcune delle aree in cui KNN può essere applicato con successo:

Sistema bancario

KNN può essere utilizzato nel sistema bancario per prevedere il tempo in cui un individuo è idoneo per l'approvazione del prestito? Quell'individuo ha le caratteristiche simili a quello degli inadempienti?

Calcolo dei rating di credito

Gli algoritmi KNN possono essere utilizzati per trovare il rating di credito di un individuo confrontandolo con persone con tratti simili.

Politica

Con l'aiuto degli algoritmi KNN, possiamo classificare un potenziale elettore in varie classi come "Voterà", "Non voterà", "Voterà al 'Congresso' del partito", "Voterà al" BJP "del partito.

Altre aree in cui è possibile utilizzare l'algoritmo KNN sono il riconoscimento vocale, il rilevamento della scrittura a mano, il riconoscimento delle immagini e il riconoscimento video.

Esistono varie metriche che possiamo utilizzare per valutare le prestazioni di algoritmi ML, classificazione e algoritmi di regressione. Dobbiamo scegliere con attenzione le metriche per valutare le prestazioni di ML perché:

• Il modo in cui vengono misurate e confrontate le prestazioni degli algoritmi di machine learning dipenderà interamente dalla metrica scelta.

• Il modo in cui ponderate l'importanza delle varie caratteristiche nel risultato sarà completamente influenzato dalla metrica scelta.

Metriche delle prestazioni per problemi di classificazione

Abbiamo discusso la classificazione e i suoi algoritmi nei capitoli precedenti. Qui, discuteremo varie metriche delle prestazioni che possono essere utilizzate per valutare le previsioni per i problemi di classificazione.

Matrice di confusione

È il modo più semplice per misurare le prestazioni di un problema di classificazione in cui l'output può essere di due o più tipi di classi. Una matrice di confusione non è altro che una tabella con due dimensioni. "Actual" e "Predicted" e inoltre, entrambe le dimensioni hanno "True Positives (TP)", "True Negatives (TN)", "False Positives (FP)", "False Negatives (FN)" come mostrato di seguito -

La spiegazione dei termini associati alla matrice di confusione è la seguente:

• True Positives (TP) - È il caso in cui sia la classe effettiva che la classe prevista del punto dati sono 1.

• True Negatives (TN) - È il caso in cui sia la classe effettiva che la classe prevista del punto dati sono 0.

• False Positives (FP) - È il caso in cui la classe effettiva del punto dati è 0 e la classe prevista del punto dati è 1.

• False Negatives (FN) - È il caso in cui la classe effettiva del punto dati è 1 e la classe prevista del punto dati è 0.

Possiamo usare la funzione confusion_matrix di sklearn.metrics per calcolare Confusion Matrix del nostro modello di classificazione.

Precisione della classificazione

È la metrica delle prestazioni più comune per gli algoritmi di classificazione. Può essere definito come il numero di previsioni corrette fatte come rapporto tra tutte le previsioni fatte. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

$Accuracy =\frac{TP+TN}{+++}$

Possiamo usare la funzione accuratezza_score di sklearn.metrics per calcolare l'accuratezza del nostro modello di classificazione.

Rapporto di classificazione

Questo rapporto è composto dai punteggi di Precisions, Recall, F1 e Support. Sono spiegati come segue:

Precisione

La precisione, utilizzata nel recupero dei documenti, può essere definita come il numero di documenti corretti restituiti dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

$Precision=\frac{TP}{TP+FP}$

Richiamo o sensibilità

Il richiamo può essere definito come il numero di positivi restituiti dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

$Recall =\frac{TP}{TP+FN}$

Specificità

La specificità, a differenza del richiamo, può essere definita come il numero di negativi restituiti dal nostro modello ML. Possiamo facilmente calcolarlo dalla matrice di confusione con l'aiuto della seguente formula:

$Specificity =\frac{TN}{TN+FP}$

Supporto

Il supporto può essere definito come il numero di campioni della risposta reale che si trova in ciascuna classe di valori target.

Punteggio F1

Questa partitura ci darà la media armonica di precisione e richiamo. Matematicamente, il punteggio F1 è la media ponderata della precisione e del richiamo. Il miglior valore di F1 sarebbe 1 e il peggiore sarebbe 0. Possiamo calcolare il punteggio F1 con l'aiuto della seguente formula:

= ∗ (∗) / (+)

Il punteggio F1 sta avendo lo stesso contributo relativo di precisione e richiamo.

Possiamo usare la funzione classification_report di sklearn.metrics per ottenere il report di classificazione del nostro modello di classificazione.

AUC (area sotto la curva ROC)

AUC (Area Under Curve) -ROC (Receiver Operating Characteristic) è una metrica delle prestazioni, basata su valori di soglia variabili, per problemi di classificazione. Come suggerisce il nome, ROC è una curva di probabilità e AUC misura la separabilità. In parole semplici, la metrica AUC-ROC ci parlerà della capacità del modello di distinguere le classi. Più alto è l'AUC, migliore è il modello.

Matematicamente, può essere creato tracciando TPR (Tasso Vero Positivo) cioè Sensibilità o Richiamo vs FPR (Tasso Falso Positivo) cioè 1-Specificità, a vari valori di soglia. Di seguito è riportato il grafico che mostra ROC, AUC con TPR sull'asse ye FPR sull'asse x -

Possiamo usare la funzione roc_auc_score di sklearn.metrics per calcolare AUC-ROC.

LOGLOSS (perdita logaritmica)

È anche chiamata perdita di regressione logistica o perdita di entropia incrociata. Fondamentalmente si definisce su stime di probabilità e misura le prestazioni di un modello di classificazione in cui l'input è un valore di probabilità compreso tra 0 e 1. Può essere compreso più chiaramente differenziandolo con accuratezza. Come sappiamo, l'accuratezza è il conteggio delle previsioni (valore previsto = valore effettivo) nel nostro modello mentre Log Loss è la quantità di incertezza della nostra previsione basata su quanto varia dall'etichetta effettiva. Con l'aiuto del valore Log Loss, possiamo avere una visione più accurata delle prestazioni del nostro modello. Possiamo usare la funzione log_loss di sklearn.metrics per calcolare la perdita di log.

Esempio

Quella che segue è una semplice ricetta in Python che ci darà un'idea di come possiamo utilizzare le metriche delle prestazioni sopra spiegate sul modello di classificazione binaria -

from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.metrics import roc_auc_score
from sklearn.metrics import log_loss
X_actual = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
Y_predic = [1, 0, 1, 1, 1, 0, 1, 1, 0, 0]
results = confusion_matrix(X_actual, Y_predic)
print ('Confusion Matrix :')
print(results)
print ('Accuracy Score is',accuracy_score(X_actual, Y_predic))
print ('Classification Report : ')
print (classification_report(X_actual, Y_predic))
print('AUC-ROC:',roc_auc_score(X_actual, Y_predic))
print('LOGLOSS Value is',log_loss(X_actual, Y_predic))

Produzione

Confusion Matrix :
[[3 3]
[1 3]]
Accuracy Score is 0.6
Classification Report :
            precision      recall      f1-score       support
      0       0.75          0.50      0.60           6
      1       0.50          0.75      0.60           4
micro avg     0.60          0.60      0.60           10
macro avg     0.62          0.62      0.60           10
weighted avg  0.65          0.60      0.60           10
AUC-ROC:  0.625
LOGLOSS Value is 13.815750437193334

Metriche delle prestazioni per problemi di regressione

Abbiamo discusso della regressione e dei suoi algoritmi nei capitoli precedenti. Qui discuteremo varie metriche delle prestazioni che possono essere utilizzate per valutare le previsioni per problemi di regressione.

Errore assoluto medio (MAE)

È la metrica di errore più semplice utilizzata nei problemi di regressione. È fondamentalmente la somma della media della differenza assoluta tra i valori previsti e quelli effettivi. In parole semplici, con MAE, possiamo avere un'idea di quanto fossero sbagliate le previsioni. MAE non indica la direzione del modello, vale a dire nessuna indicazione sulla sottoperformance o overperformance del modello. La seguente è la formula per calcolare MAE -

$MAE = \frac{1}{n}\sum|Y -\hat{Y}|$

Qui, = Valori di output effettivi

E $\hat{Y}$= Valori di output previsti.

Possiamo usare la funzione mean_absolute_error di sklearn.metrics per calcolare MAE.

Errore quadratico medio (MSE)

MSE è come il MAE, ma l'unica differenza è che quadrata la differenza dei valori di output effettivi e previsti prima di sommarli tutti invece di utilizzare il valore assoluto. La differenza può essere notata nella seguente equazione:

$MSE = \frac{1}{n}\sum(Y -\hat{Y})$

Qui, = Valori di output effettivi

E $\hat{Y}$ = Valori di output previsti.

Possiamo usare la funzione mean_squared_error di sklearn.metrics per calcolare MSE.

R quadrato (R ² )

R La metrica al quadrato viene generalmente utilizzata a scopo esplicativo e fornisce un'indicazione della bontà o dell'adattamento di un insieme di valori di output previsti ai valori di output effettivi. La seguente formula ci aiuterà a capirlo:

$R^{2} = 1 -\frac{\frac{1}{n}\sum_{i{=1}}^n(Y_{i}-\hat{Y_{i}})^2}{\frac{1}{n}\sum_{i{=1}}^n(Y_{i}-\bar{Y_i)^2}}$

Nell'equazione precedente, il numeratore è MSE e il denominatore è la varianza dei valori.

Possiamo usare la funzione r2_score di sklearn.metrics per calcolare il valore R quadrato.

Esempio

Quella che segue è una semplice ricetta in Python che ci darà un'idea di come possiamo utilizzare le metriche delle prestazioni sopra spiegate sul modello di regressione -

from sklearn.metrics import r2_score
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
X_actual = [5, -1, 2, 10]
Y_predic = [3.5, -0.9, 2, 9.9]
print ('R Squared =',r2_score(X_actual, Y_predic))
print ('MAE =',mean_absolute_error(X_actual, Y_predic))
print ('MSE =',mean_squared_error(X_actual, Y_predic))

Produzione

R Squared = 0.9656060606060606
MAE = 0.42499999999999993
MSE = 0.5674999999999999

introduzione

Per eseguire e produrre risultati con successo, un modello di machine learning deve automatizzare alcuni flussi di lavoro standard. Il processo di automatizzazione di questi flussi di lavoro standard può essere eseguito con l'aiuto di Scikit-learn Pipelines. Dal punto di vista di un data scientist, la pipeline è un concetto generalizzato ma molto importante. Fondamentalmente consente il flusso di dati dal suo formato grezzo ad alcune informazioni utili. Il funzionamento delle condutture può essere compreso con l'aiuto del seguente diagramma:

I blocchi delle pipeline ML sono i seguenti:

Data ingestion- Come suggerisce il nome, è il processo di importazione dei dati da utilizzare nel progetto ML. I dati possono essere estratti in tempo reale o batch da sistemi singoli o multipli. È uno dei passaggi più impegnativi perché la qualità dei dati può influire sull'intero modello ML.

Data Preparation- Dopo aver importato i dati, dobbiamo preparare i dati da utilizzare per il nostro modello ML. La preelaborazione dei dati è una delle tecniche più importanti di preparazione dei dati.

ML Model Training- Il prossimo passo è addestrare il nostro modello ML. Abbiamo vari algoritmi ML come rinforzo supervisionato, non supervisionato, per estrarre le caratteristiche dai dati e fare previsioni.

Model Evaluation- Successivamente, dobbiamo valutare il modello ML. In caso di pipeline AutoML, il modello ML può essere valutato con l'aiuto di vari metodi statistici e regole di business.

ML Model retraining- In caso di pipeline AutoML, non è necessario che il primo modello sia il migliore. Il primo modello è considerato come un modello di base e possiamo addestrarlo ripetutamente per aumentare la precisione del modello.

Deployment- Alla fine, dobbiamo distribuire il modello. Questa fase prevede l'applicazione e la migrazione del modello alle operazioni aziendali per il loro utilizzo.

Sfide che accompagnano le pipeline ML

Per creare pipeline ML, i data scientist devono affrontare molte sfide. Queste sfide rientrano nelle seguenti tre categorie:

Qualità dei dati

Il successo di qualsiasi modello ML dipende in larga misura dalla qualità dei dati. Se i dati che forniamo al modello ML non sono accurati, affidabili e robusti, finiremo con un output sbagliato o fuorviante.

Affidabilità dei dati

Un'altra sfida associata alle pipeline ML è l'affidabilità dei dati che forniamo al modello ML. Come sappiamo, possono esserci varie fonti da cui il data scientist può acquisire dati, ma per ottenere i migliori risultati, è necessario garantire che le fonti di dati siano affidabili e affidabili.

Accessibilità dei dati

Per ottenere i migliori risultati dalle pipeline ML, i dati stessi devono essere accessibili, il che richiede consolidamento, pulizia e cura dei dati. Come risultato della proprietà di accessibilità ai dati, i metadati verranno aggiornati con nuovi tag.

Modellazione della pipeline ML e preparazione dei dati

La perdita di dati, che si verifica dal set di dati di addestramento al set di dati di test, è un problema importante da affrontare per i data scientist durante la preparazione dei dati per il modello ML. In genere, al momento della preparazione dei dati, il data scientist utilizza tecniche come la standardizzazione o la normalizzazione sull'intero set di dati prima dell'apprendimento. Ma queste tecniche non possono aiutarci dalla fuga di dati perché il set di dati di addestramento sarebbe stato influenzato dalla scala dei dati nel set di dati di test.

Utilizzando le pipeline ML, possiamo prevenire questa perdita di dati perché le pipeline garantiscono che la preparazione dei dati come la standardizzazione sia vincolata a ogni piega della nostra procedura di convalida incrociata.

Esempio

Il seguente è un esempio in Python che dimostra la preparazione dei dati e il flusso di lavoro di valutazione del modello. A tale scopo, utilizziamo il set di dati Pima Indian Diabetes di Sklearn. Innanzitutto, creeremo una pipeline che standardizza i dati. Quindi verrà creato un modello di analisi discriminante lineare e alla fine la pipeline verrà valutata utilizzando una convalida incrociata di 10 volte.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values

Successivamente, creeremo una pipeline con l'aiuto del seguente codice:

estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('lda', LinearDiscriminantAnalysis()))
model = Pipeline(estimators)

Infine, valuteremo questa pipeline e ne produrremo l'accuratezza come segue:

kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7790148448043184

L'output sopra è il riepilogo dell'accuratezza della configurazione sul set di dati.

Modellazione di pipeline ML ed estrazione di feature

La perdita di dati può verificarsi anche nella fase di estrazione delle caratteristiche del modello ML. Questo è il motivo per cui anche le procedure di estrazione delle funzionalità dovrebbero essere limitate per bloccare la fuga di dati nel nostro set di dati di addestramento. Come nel caso della preparazione dei dati, utilizzando pipeline ML, possiamo prevenire anche questa fuga di dati. A tale scopo è possibile utilizzare FeatureUnion, uno strumento fornito dalle pipeline ML.

Esempio

Di seguito è riportato un esempio in Python che dimostra l'estrazione delle funzionalità e il flusso di lavoro di valutazione del modello. A tale scopo, utilizziamo il set di dati Pima Indian Diabetes di Sklearn.

Innanzitutto, 3 caratteristiche verranno estratte con PCA (Principal Component Analysis). Quindi, 6 caratteristiche verranno estratte con Analisi statistica. Dopo l'estrazione della feature, il risultato della selezione di più feature e le procedure di estrazione verranno combinate utilizzando

Strumento FeatureUnion. Infine, verrà creato un modello di regressione logistica e la pipeline verrà valutata utilizzando una convalida incrociata di 10 volte.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.pipeline import FeatureUnion
from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values

Successivamente, l'unione delle funzionalità verrà creata come segue:

features = []
features.append(('pca', PCA(n_components=3)))
features.append(('select_best', SelectKBest(k=6)))
feature_union = FeatureUnion(features)

Successivamente, la pipeline verrà creata con l'aiuto delle seguenti righe di script:

estimators = []
estimators.append(('feature_union', feature_union))
estimators.append(('logistic', LogisticRegression()))
model = Pipeline(estimators)

Infine, valuteremo questa pipeline e ne produrremo l'accuratezza come segue:

kfold = KFold(n_splits=20, random_state=7)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7789811066126855

L'output sopra è il riepilogo dell'accuratezza della configurazione sul set di dati.

Miglioramento delle prestazioni con gli ensemble

Gli ensemble possono darci una spinta nel risultato dell'apprendimento automatico combinando diversi modelli. Fondamentalmente, i modelli di insieme sono costituiti da diversi modelli di apprendimento supervisionato addestrati individualmente ei loro risultati vengono uniti in vari modi per ottenere migliori prestazioni predittive rispetto a un singolo modello. I metodi dell'insieme possono essere suddivisi nei seguenti due gruppi:

Metodi sequenziali dell'insieme

Come suggerisce il nome, in questo tipo di metodi di insieme, gli studenti di base vengono generati in sequenza. La motivazione di tali metodi è sfruttare la dipendenza tra gli studenti di base.

Metodi di ensemble paralleli

Come suggerisce il nome, in questo tipo di metodi di insieme, gli studenti di base vengono generati in parallelo. La motivazione di tali metodi è sfruttare l'indipendenza tra gli studenti di base.

Metodi di apprendimento dell'insieme

I seguenti sono i metodi di apprendimento d'insieme più popolari, ovvero i metodi per combinare le previsioni da diversi modelli:

Insaccamento

Il termine bagging è anche noto come aggregazione bootstrap. Nei metodi di insaccamento, il modello di insieme cerca di migliorare l'accuratezza della previsione e ridurre la varianza del modello combinando le previsioni di singoli modelli addestrati su campioni di addestramento generati casualmente. La previsione finale del modello d'insieme sarà data calcolando la media di tutte le previsioni dai singoli stimatori. Uno dei migliori esempi di metodi di insacco sono le foreste casuali.

Potenziamento

Nel metodo boosting, il principio principale della creazione di un modello di insieme è di costruirlo in modo incrementale addestrando in sequenza ogni stimatore del modello di base. Come suggerisce il nome, fondamentalmente combina diversi studenti di base settimanale, addestrati in modo sequenziale su più iterazioni di dati di formazione, per creare un insieme potente. Durante la formazione degli studenti della base settimanale, vengono assegnati pesi più elevati a quegli studenti che erano stati classificati erroneamente in precedenza. L'esempio del metodo di potenziamento è AdaBoost.

Voto

In questo modello di apprendimento dell'insieme, vengono costruiti più modelli di diversi tipi e alcune semplici statistiche, come il calcolo della media o della mediana, ecc., Vengono utilizzate per combinare le previsioni. Questa previsione servirà come input aggiuntivo per la formazione per fare la previsione finale.

Algoritmi dell'insieme di insaccamento

I seguenti sono tre algoritmi dell'insieme di insaccamento:

Albero decisionale in sacchi

Come sappiamo, i metodi dell'insieme di insaccamento funzionano bene con gli algoritmi che hanno una varianza elevata e, a questo proposito, il migliore è l'algoritmo dell'albero decisionale. Nella seguente ricetta Python, costruiremo un modello di insieme di alberi decisionali in sacchi utilizzando la funzione BaggingClassifier di sklearn con DecisionTreeClasifier (un algoritmo di classificazione e alberi di regressione) sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come abbiamo fatto negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 7
kfold = KFold(n_splits=10, random_state=seed)
cart = DecisionTreeClassifier()

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi -

num_trees = 150

Quindi, costruisci il modello con l'aiuto del seguente script:

model = BaggingClassifier(base_estimator=cart, n_estimators=num_trees, random_state=seed)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7733766233766234

L'output sopra mostra che abbiamo ottenuto circa il 77% di precisione del nostro modello di classificatore dell'albero decisionale in sacchi.

Foresta casuale

È un'estensione degli alberi decisionali in sacchi. Per i classificatori individuali, i campioni del set di dati di addestramento vengono presi con la sostituzione, ma gli alberi sono costruiti in modo tale da ridurre la correlazione tra loro. Inoltre, viene considerato un sottoinsieme casuale di caratteristiche per scegliere ogni punto di divisione piuttosto che scegliere avidamente il miglior punto di divisione nella costruzione di ogni albero.

Nella seguente ricetta di Python, costruiremo un modello di insieme di foreste casuali in sacchi utilizzando la classe di sklearn RandomForestClassifier sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi con punti di divisione scelti tra 5 caratteristiche:

num_trees = 150
max_features = 5

Quindi, costruisci il modello con l'aiuto del seguente script:

model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7629357484620642

L'output sopra mostra che abbiamo ottenuto circa il 76% di precisione del nostro modello di classificatore di foreste casuali in sacchi.

Alberi extra

È un'altra estensione del metodo dell'insieme dell'albero decisionale in sacchi. In questo metodo, gli alberi casuali vengono costruiti dai campioni del set di dati di addestramento.

Nella seguente ricetta Python, costruiremo un modello di insieme di alberi extra utilizzando la classe di sklearn ExtraTreesClassifier sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi con punti di divisione scelti tra 5 caratteristiche:

num_trees = 150
max_features = 5

Quindi, costruisci il modello con l'aiuto del seguente script:

model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7551435406698566

L'output sopra mostra che abbiamo ottenuto circa il 75,5% di precisione del nostro modello di classificatore di alberi extra in sacchi.

Potenziamento degli algoritmi dell'insieme

I seguenti sono i due algoritmi di boosting ensemble più comuni:

AdaBoost

È uno degli algoritmi di potenziamento dell'insieme di maggior successo. La chiave principale di questo algoritmo è nel modo in cui danno i pesi alle istanze nel set di dati. Per questo motivo, l'algoritmo deve prestare meno attenzione alle istanze durante la costruzione dei modelli successivi.

Nella seguente ricetta Python, costruiremo un modello di insieme Ada Boost per la classificazione utilizzando la classe di sklearn AdaBoostClassifier sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import AdaBoostClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi con punti di divisione scelti tra 5 caratteristiche:

num_trees = 50

Quindi, costruisci il modello con l'aiuto del seguente script:

model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7539473684210527

L'output sopra mostra che abbiamo ottenuto circa il 75% di precisione del nostro modello di insieme di classificatori AdaBoost.

Aumento del gradiente stocastico

Si chiama anche Gradient Boosting Machines. Nella seguente ricetta Python, costruiremo il modello Stochastic Gradient Boostingensemble per la classificazione utilizzando la classe GradientBoostingClassifier di sklearn sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

Dobbiamo fornire il numero di alberi che costruiremo. Qui stiamo costruendo 150 alberi con punti di divisione scelti tra 5 caratteristiche:

num_trees = 50

Quindi, costruisci il modello con l'aiuto del seguente script:

model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)

Calcola e stampa il risultato come segue:

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7746582365003418

L'output sopra mostra che abbiamo ottenuto circa il 77,5% di accuratezza del nostro modello di ensemble classificatore Gradient Boosting.

Voting Ensemble Algorithms

Come discusso, la votazione crea prima due o più modelli autonomi dal set di dati di addestramento e quindi un classificatore di voto avvolgerà il modello insieme alla media delle previsioni del sottomodello ogni volta che saranno necessari nuovi dati.

Nella seguente ricetta Python, costruiremo un modello di ensemble di voto per la classificazione utilizzando la classe VotingClassifier di sklearn sul set di dati sul diabete degli indiani Pima. Stiamo combinando le previsioni di regressione logistica, classificatore dell'albero decisionale e SVM insieme per un problema di classificazione come segue:

Innanzitutto, importa i pacchetti richiesti come segue:

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Quindi, fornire l'input per la convalida incrociata di 10 volte come segue:

kfold = KFold(n_splits=10, random_state=7)

Successivamente, dobbiamo creare sottomodelli come segue:

estimators = []
model1 = LogisticRegression()
estimators.append(('logistic', model1))
model2 = DecisionTreeClassifier()
estimators.append(('cart', model2))
model3 = SVC()
estimators.append(('svm', model3))

Ora, crea il modello di insieme di voto combinando le previsioni dei sottomodelli creati sopra.

ensemble = VotingClassifier(estimators)
results = cross_val_score(ensemble, X, Y, cv=kfold)
print(results.mean())

Produzione

0.7382262474367738

L'output sopra mostra che abbiamo ottenuto circa il 74% di precisione del nostro modello di ensemble di classificatori di voto.

Miglioramento delle prestazioni con l'ottimizzazione dell'algoritmo

Come sappiamo, i modelli ML sono parametrizzati in modo tale che il loro comportamento possa essere regolato per un problema specifico. L'ottimizzazione dell'algoritmo significa trovare la migliore combinazione di questi parametri in modo che le prestazioni del modello ML possano essere migliorate. Questo processo a volte chiamato ottimizzazione iperparametrica ei parametri dell'algoritmo stesso sono chiamati iperparametri e i coefficienti trovati dall'algoritmo ML sono chiamati parametri.

Qui discuteremo di alcuni metodi per la regolazione dei parametri degli algoritmi forniti da Python Scikit-learn.

Regolazione dei parametri di ricerca della griglia

È un approccio di regolazione dei parametri. Il punto chiave del funzionamento di questo metodo è che costruisce e valuta il modello metodicamente per ogni possibile combinazione di parametri di algoritmo specificati in una griglia. Quindi, possiamo dire che questo algoritmo ha natura di ricerca.

Esempio

Nella seguente ricetta Python, eseguiremo la ricerca sulla griglia utilizzando la classe di sklearn GridSearchCV per valutare vari valori alfa per l'algoritmo di regressione di Ridge sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

import numpy
from pandas import read_csv
from sklearn.linear_model import Ridge
from sklearn.model_selection import GridSearchCV

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Quindi, valuta i vari valori alfa come segue:

alphas = numpy.array([1,0.1,0.01,0.001,0.0001,0])
param_grid = dict(alpha=alphas)

Ora, dobbiamo applicare la ricerca griglia sul nostro modello:

model = Ridge()
grid = GridSearchCV(estimator=model, param_grid=param_grid)
grid.fit(X, Y)

Stampa il risultato con la seguente riga di script:

print(grid.best_score_)
print(grid.best_estimator_.alpha)

Produzione

0.2796175593129722
1.0

L'output di cui sopra ci fornisce il punteggio ottimale e l'insieme di parametri nella griglia che hanno raggiunto quel punteggio. Il valore alfa in questo caso è 1.0.

Sintonizzazione dei parametri di ricerca casuale

È un approccio di regolazione dei parametri. Il punto chiave del funzionamento di questo metodo è che campiona i parametri dell'algoritmo da una distribuzione casuale per un numero fisso di iterazioni.

Esempio

Nella seguente ricetta Python, eseguiremo una ricerca casuale utilizzando la classe di sklearn RandomizedSearchCV per valutare diversi valori alfa tra 0 e 1 per l'algoritmo di regressione della cresta sul set di dati del diabete degli indiani Pima.

Innanzitutto, importa i pacchetti richiesti come segue:

import numpy
from pandas import read_csv
from scipy.stats import uniform
from sklearn.linear_model import Ridge
from sklearn.model_selection import RandomizedSearchCV

Ora, dobbiamo caricare il set di dati sul diabete Pima come negli esempi precedenti -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Quindi, valuta i vari valori alfa sull'algoritmo di regressione di Ridge come segue:

param_grid = {'alpha': uniform()}
model = Ridge()
random_search = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=50,
random_state=7)
random_search.fit(X, Y)

Stampa il risultato con la seguente riga di script:

print(random_search.best_score_)
print(random_search.best_estimator_.alpha)

Produzione

0.27961712703051084
0.9779895119966027
0.9779895119966027

L'output sopra ci fornisce il punteggio ottimale proprio simile alla ricerca sulla griglia.