AI con Python - Deep Learning

Artificial Neural Network (ANN) è un efficiente sistema di calcolo, il cui tema centrale è mutuato dall'analogia delle reti neurali biologiche. Le reti neurali sono un tipo di modello per l'apprendimento automatico. A metà degli anni '80 e all'inizio degli anni '90, sono stati fatti progressi architettonici molto importanti nelle reti neurali. In questo capitolo imparerai di più sul Deep Learning, un approccio all'IA.

L'apprendimento profondo è emerso da un'esplosiva crescita computazionale di un decennio come un serio contendente nel campo. Pertanto, l'apprendimento profondo è un particolare tipo di apprendimento automatico i cui algoritmi sono ispirati dalla struttura e dalla funzione del cervello umano.

Machine learning v / s deep learning

Il deep learning è la tecnica di machine learning più potente di questi tempi. È così potente perché imparano il modo migliore per rappresentare il problema mentre imparano a risolvere il problema. Di seguito viene fornito un confronto tra Deep learning e Machine learning:

Dipendenza dai dati

Il primo punto di differenza si basa sulle prestazioni di DL e ML quando la scala dei dati aumenta. Quando i dati sono grandi, gli algoritmi di deep learning funzionano molto bene.

Dipendenza dalla macchina

Gli algoritmi di deep learning richiedono macchine di fascia alta per funzionare perfettamente. D'altra parte, gli algoritmi di apprendimento automatico possono funzionare anche su macchine di fascia bassa.

Estrazione delle caratteristiche

Gli algoritmi di deep learning possono estrarre funzionalità di alto livello e cercare di imparare anche dalle stesse. D'altra parte, è necessario un esperto per identificare la maggior parte delle funzionalità estratte dal machine learning.

Tempo di esecuzione

Il tempo di esecuzione dipende dai numerosi parametri utilizzati in un algoritmo. Il deep learning ha più parametri degli algoritmi di machine learning. Quindi, il tempo di esecuzione degli algoritmi DL, specialmente il tempo di addestramento, è molto più degli algoritmi ML. Ma il tempo di test degli algoritmi DL è inferiore agli algoritmi ML.

Approccio alla risoluzione dei problemi

Il deep learning risolve il problema end-to-end mentre il machine learning utilizza il modo tradizionale di risolvere il problema, ovvero suddividendolo in parti.

Rete neurale convoluzionale (CNN)

Le reti neurali convoluzionali sono le stesse delle reti neurali ordinarie perché sono costituite anche da neuroni che hanno pesi e pregiudizi apprendibili. Le reti neurali ordinarie ignorano la struttura dei dati di input e tutti i dati vengono convertiti in array 1-D prima di immetterli nella rete. Questo processo si adatta ai dati normali, tuttavia se i dati contengono immagini, il processo potrebbe essere complicato.

La CNN risolve facilmente questo problema. Prende in considerazione la struttura 2D delle immagini quando le elaborano, il che consente loro di estrarre le proprietà specifiche delle immagini. In questo modo, l'obiettivo principale delle CNN è passare dai dati dell'immagine grezza nel livello di input alla classe corretta nel livello di output. L'unica differenza tra un normale NN e CNN è nel trattamento dei dati di input e nel tipo di strati.

Panoramica dell'architettura delle CNN

Architettonicamente, le reti neurali ordinarie ricevono un input e lo trasformano attraverso una serie di strati nascosti. Ogni strato è connesso all'altro strato con l'aiuto dei neuroni. Il principale svantaggio delle reti neurali ordinarie è che non si adattano bene alle immagini complete.

L'architettura delle CNN ha neuroni disposti in 3 dimensioni chiamate larghezza, altezza e profondità. Ogni neurone nel livello corrente è collegato a una piccola patch dell'output dal livello precedente. È simile alla sovrapposizione di un file×filtro sull'immagine in ingresso. UtilizzaMfiltri per essere sicuri di ottenere tutti i dettagli. QuesteM i filtri sono estrattori di funzionalità che estraggono elementi come bordi, angoli, ecc.

Livelli utilizzati per costruire CNN

I seguenti livelli vengono utilizzati per costruire le CNN:

  • Input Layer - Prende i dati dell'immagine grezza così come sono.

  • Convolutional Layer- Questo livello è l'elemento fondamentale delle CNN che esegue la maggior parte dei calcoli. Questo strato calcola le convoluzioni tra i neuroni e le varie patch nell'input.

  • Rectified Linear Unit Layer- Applica una funzione di attivazione all'uscita del livello precedente. Aggiunge non linearità alla rete in modo che possa generalizzarsi bene a qualsiasi tipo di funzione.

  • Pooling Layer- Il pooling ci aiuta a mantenere solo le parti importanti mentre progrediamo nella rete. Il livello di raggruppamento opera in modo indipendente su ogni sezione di profondità dell'input e lo ridimensiona spazialmente. Utilizza la funzione MAX.

  • Fully Connected layer/Output layer - Questo livello calcola i punteggi di output nell'ultimo livello. L'output risultante è della dimensione×× , dove L è il numero di classi del set di dati di addestramento.

Installazione di pacchetti Python utili

Puoi usare Keras, che è un'API per reti neurali di alto livello, scritta in Python e in grado di funzionare su TensorFlow, CNTK o Theno. È compatibile con Python 2.7-3.6. Puoi saperne di più suhttps://keras.io/.

Usa i seguenti comandi per installare keras:

pip install keras

Sopra conda ambiente, puoi usare il seguente comando:

conda install –c conda-forge keras

Costruire un regressore lineare utilizzando ANN

In questa sezione imparerai come costruire un regressore lineare utilizzando reti neurali artificiali. Puoi usareKerasRegressor to achieve this. In this example, we are using the Boston house price dataset with 13 numerical for properties in Boston. The Python code for the same is shown here −

Import all the required packages as shown −

import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold

Now, load our dataset which is saved in local directory.

dataframe = pandas.read_csv("/Usrrs/admin/data.csv", delim_whitespace = True, header = None)
dataset = dataframe.values

Now, divide the data into input and output variables i.e. X and Y −

X = dataset[:,0:13]
Y = dataset[:,13]

Since we use baseline neural networks, define the model −

def baseline_model():

Now, create the model as follows −

model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initializer = 'normal', 
   activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))

Next, compile the model −

model_regressor.compile(loss='mean_squared_error', optimizer='adam')
return model_regressor

Now, fix the random seed for reproducibility as follows −

seed = 7
numpy.random.seed(seed)

The Keras wrapper object for use in scikit-learn as a regression estimator is called KerasRegressor. In this section, we shall evaluate this model with standardize data set.

estimator = KerasRegressor(build_fn = baseline_model, nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_splits = 10, random_state = seed)
baseline_result = cross_val_score(estimator, X, Y, cv = kfold)
print("Baseline: %.2f (%.2f) MSE" % (Baseline_result.mean(),Baseline_result.std()))

The output of the code shown above would be the estimate of the model’s performance on the problem for unseen data. It will be the mean squared error, including the average and standard deviation across all 10 folds of the cross validation evaluation.

Image Classifier: An Application of Deep Learning

Convolutional Neural Networks (CNNs) solve an image classification problem, that is to which class the input image belongs to. You can use Keras deep learning library. Note that we are using the training and testing data set of images of cats and dogs from following link https://www.kaggle.com/c/dogs-vs-cats/data.

Import the important keras libraries and packages as shown −

The following package called sequential will initialize the neural networks as sequential network.

from keras.models import Sequential

The following package called Conv2D is used to perform the convolution operation, the first step of CNN.

from keras.layers import Conv2D

The following package called MaxPoling2D is used to perform the pooling operation, the second step of CNN.

from keras.layers import MaxPooling2D

The following package called Flatten is the process of converting all the resultant 2D arrays into a single long continuous linear vector.

from keras.layers import Flatten

The following package called Dense is used to perform the full connection of the neural network, the fourth step of CNN.

from keras.layers import Dense

Now, create an object of the sequential class.

S_classifier = Sequential()

Now, next step is coding the convolution part.

S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))

Here relu is the rectifier function.

Now, the next step of CNN is the pooling operation on the resultant feature maps after convolution part.

S-classifier.add(MaxPooling2D(pool_size = (2, 2)))

Now, convert all the pooled images into a continuous vector by using flattering −

S_classifier.add(Flatten())

Next, create a fully connected layer.

S_classifier.add(Dense(units = 128, activation = 'relu'))

Here, 128 is the number of hidden units. It is a common practice to define the number of hidden units as the power of 2.

Now, initialize the output layer as follows −

S_classifier.add(Dense(units = 1, activation = 'sigmoid'))

Now, compile the CNN, we have built −

S_classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

Here optimizer parameter is to choose the stochastic gradient descent algorithm, loss parameter is to choose the loss function and metrics parameter is to choose the performance metric.

Now, perform image augmentations and then fit the images to the neural networks −

train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)

training_set = 
   train_datagen.flow_from_directory(”/Users/admin/training_set”,target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

test_set = 
   test_datagen.flow_from_directory('test_set',target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

Now, fit the data to the model we have created −

classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs = 
25,validation_data = test_set,validation_steps = 2000)

Here steps_per_epoch have the number of training images.

Now as the model has been trained, we can use it for prediction as follows −

from keras.preprocessing import image

test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg', 
target_size = (64, 64))

test_image = image.img_to_array(test_image)

test_image = np.expand_dims(test_image, axis = 0)

result = classifier.predict(test_image)

training_set.class_indices

if result[0][0] == 1:
prediction = 'dog'

else:
   prediction = 'cat'