08-deep-learning.Rmd

# Deep Learning

## Artificial Neural Network

### Importing the libraries

**Python**

```{python}
import numpy as np
import pandas as pd
import tensorflow as tf
tf.__version__
```

### Part 1 - Data Preprocessing {.unnumbered}

### Importing the dataset

**Python**

```{python}
dataset = pd.read_csv('Churn_Modelling.csv')
X = dataset.iloc[:, 3:-1].values
y = dataset.iloc[:, -1].values
print(X)
print(y)
```

**R**

```{r}
dataset = read.csv('Churn_Modelling.csv')
dataset = dataset[4:14]
```

### Encoding categorical data

**Python**

```{python}
# Label Encoding the "Gender" column
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
X[:, 2] = le.fit_transform(X[:, 2])
print(X)
# One Hot Encoding the "Geography" column
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [1])], remainder='passthrough')
X = np.array(ct.fit_transform(X))
print(X)
```

**R**

```{r}
dataset$Geography = as.numeric(factor(dataset$Geography,
                                      levels = c('France', 'Spain', 'Germany'),
                                      labels = c(1, 2, 3)))
dataset$Gender = as.numeric(factor(dataset$Gender,
                                   levels = c('Female', 'Male'),
                                   labels = c(1, 2)))
```

### Splitting the dataset into the Training set and Test set

**Python**

```{python}
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
```

**R**

```{r}
# install.packages('caTools')
library(caTools)
set.seed(123)
split = sample.split(dataset$Exited, SplitRatio = 0.8)
training_set = subset(dataset, split == TRUE)
test_set = subset(dataset, split == FALSE)
```

### Feature Scaling

**Python**

```{python}
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
```

**R**

```{r}
training_set[-11] = scale(training_set[-11])
test_set[-11] = scale(test_set[-11])
```

### Part 2 - Building the ANN {.unnumbered}

### Initializing the ANN

**Python**

```{python}
# ann = tf.keras.models.Sequential()
from tensorflow.keras.models import Sequential
ann = Sequential()
```

### Adding the input layer and the first hidden layer

**Python**

```{python}
ann.add(tf.keras.layers.Dense(units=6, activation='relu'))
```

### Adding the second hidden layer

**Python**

```{python}
ann.add(tf.keras.layers.Dense(units=6, activation='relu'))
```

### Adding the output layer

**Python**

```{python}
ann.add(tf.keras.layers.Dense(units=1, activation='sigmoid'))
```

### Part 3 - Training the ANN {.unnumbered}

### Compiling the ANN

**Python**

```{python}
ann.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
```

### Training the ANN on the Training set

**Python**

```{python, cache = TRUE}
ann.fit(X_train, y_train, batch_size = 32, epochs = 100)
```

**R**

```{r}
# install.packages('h2o')
library(h2o)
h2o.init(nthreads = -1)
model = h2o.deeplearning(y = 'Exited',
                         training_frame = as.h2o(training_set),
                         activation = 'Rectifier',
                         hidden = c(5,5),
                         epochs = 100,
                         train_samples_per_iteration = -2)
```

### Part 4 - Making the predictions and evaluating the model {.unnumbered}

### Predicting the result of a single observation

**Python**

```{python}

"""
Homework:
Use our ANN model to predict if the customer with the following informations will leave the bank: 
Geography: France
Credit Score: 600
Gender: Male
Age: 40 years old
Tenure: 3 years
Balance: $ 60000
Number of Products: 2
Does this customer have a credit card? Yes
Is this customer an Active Member: Yes
Estimated Salary: $ 50000
So, should we say goodbye to that customer?

Solution:
"""

print(ann.predict(sc.transform([[1, 0, 0, 600, 1, 40, 3, 60000, 2, 1, 1, 50000]])) > 0.5)

"""
Therefore, our ANN model predicts that this customer stays in the bank!
Important note 1: Notice that the values of the features were all input in a double pair of square brackets. That's because the "predict" method always expects a 2D array as the format of its inputs. And putting our values into a double pair of square brackets makes the input exactly a 2D array.
Important note 2: Notice also that the "France" country was not input as a string in the last column but as "1, 0, 0" in the first three columns. That's because of course the predict method expects the one-hot-encoded values of the state, and as we see in the first row of the matrix of features X, "France" was encoded as "1, 0, 0". And be careful to include these values in the first three columns, because the dummy variables are always created in the first columns.
"""
```

### Predicting the Test set results

**Python**

```{python}
y_pred = ann.predict(X_test)
y_pred = (y_pred > 0.5)
print(np.concatenate((y_pred.reshape(len(y_pred),1), y_test.reshape(len(y_test),1)),1))
```

**R**

```{r}
y_pred = h2o.predict(model, newdata = as.h2o(test_set[-11]))
y_pred = (y_pred > 0.5)
y_pred = as.vector(y_pred)
```

### Making the Confusion Matrix

**Python**

```{python}
from sklearn.metrics import confusion_matrix, accuracy_score
cm = confusion_matrix(y_test, y_pred)
print(cm)
accuracy_score(y_test, y_pred)
```

**R**

```{r}
cm = table(test_set[, 11], y_pred)
```

```{r}
# h2o.shutdown()
```

## Convolutional Neural Network

### Importing the libraries

**Python**

```{python}
import tensorflow as tf
# from keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.preprocessing.image import ImageDataGenerator
tf.__version__
```

### Part 1 - Data Preprocessing {.unnumbered}

### Preprocessing the Training set

**Python**

```{python}
train_datagen = ImageDataGenerator(rescale = 1./255,
                                   shear_range = 0.2,
                                   zoom_range = 0.2,
                                   horizontal_flip = True)
training_set = train_datagen.flow_from_directory('dataset/training_set',
                                                 target_size = (64, 64),
                                                 batch_size = 32,
                                                 class_mode = 'binary')
```

### Preprocessing the Test set

**Python**

```{python}
test_datagen = ImageDataGenerator(rescale = 1./255)
test_set = test_datagen.flow_from_directory('dataset/test_set',
                                            target_size = (64, 64),
                                            batch_size = 32,
                                            class_mode = 'binary')
```

### Part 2 - Building the CNN {.unnumbered}

### Initialising the CNN

**Python**

```{python}
cnn = tf.keras.models.Sequential()
# from tensorflow.keras.models import Sequential
# cnn = Sequential()
```

#### Step 1 - Convolution {.unnumbered}

**Python**

```{python}
cnn.add(tf.keras.layers.Conv2D(filters=32, kernel_size=3, activation='relu', input_shape=[64, 64, 3]))
```

#### Step 2 - Pooling

**Python**

```{python}
cnn.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2))
```

### Adding a second convolutional layer

**Python**

```{python}
cnn.add(tf.keras.layers.Conv2D(filters=32, kernel_size=3, activation='relu'))
cnn.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2))
```

#### Step 3 - Flattening {.unnumbered}

**Python**

```{python}
cnn.add(tf.keras.layers.Flatten())
```

#### Step 4 - Full Connection {.unnumbered}

**Python**

```{python}
cnn.add(tf.keras.layers.Dense(units=128, activation='relu'))
```

#### Step 5 - Output Layer {.unnumbered}

**Python**

```{python}
cnn.add(tf.keras.layers.Dense(units=1, activation='sigmoid'))
```

### Part 3 - Training the CNN {.unnumbered}

### Compiling the CNN

**Python**

```{python}
cnn.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
```

### Training the CNN on the Training set and evaluating it on the Test set

**Python**

```{python, cache = TRUE}
cnn.fit(x = training_set, validation_data = test_set, epochs = 25)
```

### Part 4 - Making a single prediction {.unnumbered}

**Python**

```{python}
import numpy as np
# from keras.preprocessing import image
from tensorflow.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 = cnn.predict(test_image)
training_set.class_indices
if result[0][0] == 1:
    prediction = 'dog'
else:
    prediction = 'cat'
print(prediction)
```