Deep Learning en Python - Implementaciones  

  RSS
admin
(@admin)
Miembro Admin

En esta implementación de Deep Learning, nuestro objetivo es predecir la rotación de datos de un determinado banco, y es probable que los clientes abandonen este servicio bancario. El conjunto de datos utilizado es relativamente pequeño y contiene 10000 filas con 14 columnas. Estamos utilizando la distribución de Anaconda y marcos como Theano, TensorFlow y Keras. Keras está construido sobre Tensorflow y Theano que funcionan como backends.

# Red neuronal artificial
# Instalando Theano
pip install --upgrade theano

# Instalando Tensorflow
pip install –upgrade tensorflow

# Instalando Keras
pip install --upgrade keras

Paso 1: preprocesamiento de datos

In[]:

# Importando las bibliotecas
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Importando la base de datos
dataset = pd.read_csv('Churn_Modelling.csv')

Paso 2

Creamos matrices de las características del conjunto de datos y la variable de destino, que es la columna 14, etiquetada como "Salida".

El aspecto inicial de los datos se muestra a continuación:

In[]:
X = dataset.iloc[:, 3:13].values
Y = dataset.iloc[:, 13].values
X

Salida

Paso 3

Y

Salida

array([1, 0, 1, ..., 1, 1, 0], dtype = int64)

Etapa 4

Hacemos el análisis más simple codificando las variables de cadena. Estamos utilizando la función ScikitLearn 'LabelEncoder' para codificar automáticamente las diferentes etiquetas en las columnas con valores entre 0 y n_classes-1.

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X_1 = LabelEncoder()
X[:,1] = labelencoder_X_1.fit_transform(X[:,1])
labelencoder_X_2 = LabelEncoder()
X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2])
X

Salida

En la salida anterior, los nombres de los países se reemplazan por 0, 1 y 2; mientras que masculino y femenino son reemplazados por 0 y 1.

Paso 5

Etiquetado de datos codificados

Usamos la misma biblioteca ScikitLearn y otra función llamada OneHotEncoder para simplemente pasar el número de columna creando una variable ficticia.

onehotencoder = OneHotEncoder(categorical features = [1])
X = onehotencoder.fit_transform(X).toarray()
X = X[:, 1:]
X

Ahora, las dos primeras columnas representan el país y la cuarta columna representa el género.

Salida

Siempre dividimos nuestros datos en parte de entrenamiento y pruebas; entrenamos a nuestro modelo en datos de entrenamiento y luego verificamos la precisión de un modelo en datos de prueba que ayuda a evaluar la eficiencia del modelo.

Paso 6

Estamos utilizando la función train_test_split de ScikitLearn para dividir nuestros datos en conjunto de entrenamiento y conjunto de prueba. Mantenemos la relación de división en 80:20.

# Dividir el conjunto de datos en el conjunto de entrenamiento y el conjunto de prueba
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)

Algunas variables tienen valores en miles, mientras que otras tienen valores en decenas o en unidades. Escalamos los datos para que sean más representativos.

Paso 7

En este código, estamos ajustando y transformando los datos de entrenamiento utilizando la función StandardScaler. Normalizamos nuestra escala de modo que utilicemos el mismo método ajustado para transformar/escalar datos de prueba.

# Característica de escalado
fromsklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

Salida

Los datos ahora se escalan correctamente. Finalmente, hemos terminado con nuestro preprocesamiento de datos. Ahora, vamos a empezar con nuestro modelo.

Paso 8

Importamos los módulos requeridos aquí. Necesitamos el módulo secuencial para inicializar la red neuronal y el módulo denso para agregar las capas ocultas.

# Importando las librerías y paquetes de Keras. 
import keras
from keras.models import Sequential
from keras.layers import Dense

Paso 9

Nombraremos el modelo como Clasificador, ya que nuestro objetivo es clasificar la rotación de clientes. Luego usamos el módulo secuencial para la inicialización.

# Inicializando red neuronal
classifier = Sequential()

Paso 10

Añadimos las capas ocultas una a una usando la función densa. En el código de abajo, veremos muchos argumentos.

Nuestro primer parámetro es output_dim. Es el número de nodos que agregamos a esta capa. init es la inicialización del gradiente estocástico decente. En una red neuronal asignamos ponderaciones a cada nodo. En la inicialización, los pesos deben estar cerca de cero e inicializamos los pesos aleatoriamente usando la función uniforme. El parámetro input_dim es necesario solo para la primera capa, ya que el modelo no conoce el número de nuestras variables de entrada. Aquí, el número total de variables de entrada es 11. En la segunda capa, el modelo conoce automáticamente el número de variables de entrada de la primera capa oculta.

Ejecute la siguiente línea de código para agregar la capa de entrada y la primera capa oculta:

classifier.add(Dense(units = 6, kernel_initializer = 'uniform', 
activation = 'relu', input_dim = 11))

Ejecute la siguiente línea de código para agregar la segunda capa oculta:

classifier.add(Dense(units = 6, kernel_initializer = 'uniform', 
activation = 'relu'))

Ejecute la siguiente línea de código para agregar la capa de salida:

classifier.add(Dense(units = 1, kernel_initializer = 'uniform', 
activation = 'sigmoid'))

Paso 11

Compilando la ANN

Hemos añadido varias capas a nuestro clasificador hasta ahora. Ahora los compilaremos usando el método de compilación. Los argumentos agregados en el control de compilación final completan la red neuronal. Por lo tanto, debemos tener cuidado en este paso.

Aquí hay una breve explicación de los argumentos:

El primer argumento es Optimizer. Este es un algoritmo utilizado para encontrar el conjunto óptimo de ponderaciones. Este algoritmo se llama Descenso Estocástico de Gradiente (SGD). Aquí estamos usando uno entre varios tipos, llamado 'Adam optimizer'. El SGD depende de la pérdida, por lo que nuestro segundo parámetro es la pérdida. Si nuestra variable dependiente es binaria, usamos la función de pérdida logarítmica llamada 'binary_crossentropy', y si nuestra variable dependiente tiene más de dos categorías en la salida, entonces usamos 'categorical_crossentropy'. Queremos mejorar el rendimiento de nuestra red neuronal en función de la precisión, por lo que agregamos métricas como precisión.

# Compilando red neuronal 
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

Paso 12

Se deben ejecutar varios códigos en este paso.

Ajuste de la ANN al conjunto de entrenamiento

Ahora entrenamos nuestro modelo en los datos de entrenamiento. Usamos el método de ajuste para que se adapte a nuestro modelo. También optimizamos los pesos para mejorar la eficiencia del modelo. Para ello, tenemos que actualizar los pesos. El tamaño del lote es el número de observaciones después de lo cual actualizamos los pesos. 'epochs' es el número total de iteraciones. Los valores de tamaño de lote y 'epochs' se eligen mediante el método de prueba y error.

classifier.fit(X_train, y_train, batch_size = 10, epochs = 50)

Haciendo predicciones y evaluando el modelo

# Predecir los resultados del conjunto de pruebas
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)

Predecir una sola observación nueva

# Predecir una sola observación nueva
"""Our goal is to predict if the customer with the following data will leave the bank:
Geography: Spain
Credit Score: 500
Gender: Female
Age: 40
Tenure: 3
Balance: 50000
Number of Products: 2
Has Credit Card: Yes
Is Active Member: Yes

Paso 13

Predecir el resultado del conjunto de pruebas

Para continuar viendo el resto de contenido por favor Regístrate o Inicia Sección

This topic was modified hace 4 meses 2 times by admin
This topic was modified hace 2 meses 2 times by admin
ResponderCitar
Respondido : 09/10/2018 4:33 pm
Share:
  
Trabajando

Por favor Iniciar Sesión o Registro