diff --git a/.DS_Store b/.DS_Store index 79f883c4..bcfedd97 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/datasets/.DS_Store b/datasets/.DS_Store index b5d65335..931125af 100644 Binary files a/datasets/.DS_Store and b/datasets/.DS_Store differ diff --git a/datasets/Get the Machine Learning Basics/Classification Template/.DS_Store b/datasets/Get the Machine Learning Basics/Classification Template/.DS_Store index 21a67435..93fcf85c 100644 Binary files a/datasets/Get the Machine Learning Basics/Classification Template/.DS_Store and b/datasets/Get the Machine Learning Basics/Classification Template/.DS_Store differ diff --git a/datasets/Get the Machine Learning Basics/Classification Template/Classification Template/logistic_regression.py b/datasets/Get the Machine Learning Basics/Classification Template/Classification Template/logistic_regression.py new file mode 100644 index 00000000..a46f5b1a --- /dev/null +++ b/datasets/Get the Machine Learning Basics/Classification Template/Classification Template/logistic_regression.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Feb 5 18:37:58 2020 + +@author: ramonpuga +""" + +# Regresion Logística + +# Importar las librerias +import numpy as np +import matplotlib.pyplot as plt +import pandas as pd + +# Importar el dataset +dataset = pd.read_csv('Social_Network_Ads.csv') + +# Matriz X con todas las filas, y todas las columnas menos la última +X = dataset.iloc[:, [2,3]].values +# Vector y con todas las filas y la última columna +y = dataset.iloc[:, -1].values + +# Dividir el data set en conjunto de training y de test +from sklearn.model_selection import train_test_split +# Aplicamos un porcentaje del 25% (0.25) para el test y un valor de selección alatoria de 0 +X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0) + +# Escalado (estandarización o normalización) de variables +from sklearn.preprocessing import StandardScaler +sc_X = StandardScaler() +# Aplicamos y fijamos el metodo de estandarización a todas las columnas X +X_train = sc_X.fit_transform(X_train) +# Aplicamos el mismo metodo de estandarización que para los datos de Training +X_test = sc_X.transform(X_test) + +# Ajustar el modelo de Regresión Logística en el Conjunto de Training +from sklearn.linear_model import LogisticRegression +classifier = LogisticRegression(random_state = 0) +classifier.fit(X_train, y_train) + +# Predicción de los resultados con el conjunto de Testing +y_pred = classifier.predict(X_test) + +# Elaborar una matriz de confusión +from sklearn.metrics import confusion_matrix +cm = confusion_matrix(y_test, y_pred) + +# Representación gráfica de los resultados del algoritmo +from matplotlib.colors import ListedColormap +X_set, y_set = X_train, y_train +X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01), + np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01)) +plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), + alpha = 0.75, cmap = ListedColormap(('red', 'green'))) +plt.xlim(X1.min(), X1.max()) +plt.ylim(X2.min(), X2.max()) +for i, j in enumerate(np.unique(y_set)): + plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1], + c = ListedColormap(('red', 'green'))(i), label = j) +plt.title('Clasificador (Conjunto de Training)') +plt.xlabel('Edad') +plt.ylabel('Sueldo Estimado') +plt.legend() +plt.show() + +# Representación gráfica de los resultados del algoritmo +from matplotlib.colors import ListedColormap +X_set, y_set = X_test, y_test +X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01), + np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01)) +plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), + alpha = 0.75, cmap = ListedColormap(('red', 'green'))) +plt.xlim(X1.min(), X1.max()) +plt.ylim(X2.min(), X2.max()) +for i, j in enumerate(np.unique(y_set)): + plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1], + c = ListedColormap(('red', 'green'))(i), label = j) +plt.title('Clasificador (Conjunto de Test)') +plt.xlabel('Edad') +plt.ylabel('Sueldo Estimado') +plt.legend() +plt.show() \ No newline at end of file diff --git a/datasets/Get the Machine Learning Basics/Classification Template/Classification Template/my_classification_template.py b/datasets/Get the Machine Learning Basics/Classification Template/Classification Template/my_classification_template.py new file mode 100644 index 00000000..8a20eae0 --- /dev/null +++ b/datasets/Get the Machine Learning Basics/Classification Template/Classification Template/my_classification_template.py @@ -0,0 +1,84 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Feb 5 21:13:23 2020 + +@author: ramonpuga +""" + +# Plantilla de Clasificación + +# Importar las librerias +import numpy as np +import matplotlib.pyplot as plt +import pandas as pd + +# Importar el dataset +dataset = pd.read_csv('Social_Network_Ads.csv') + +# Matriz X con todas las filas, y todas las columnas menos la última +X = dataset.iloc[:, [2,3]].values +# Vector y con todas las filas y la última columna +y = dataset.iloc[:, -1].values + +# Dividir el data set en conjunto de training y de test +from sklearn.model_selection import train_test_split +# Aplicamos un porcentaje del 25% (0.25) para el test y un valor de selección alatoria de 0 +X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0) + +# Escalado (estandarización o normalización) de variables +from sklearn.preprocessing import StandardScaler +sc_X = StandardScaler() +# Aplicamos y fijamos el metodo de estandarización a todas las columnas X +X_train = sc_X.fit_transform(X_train) +# Aplicamos el mismo metodo de estandarización que para los datos de Training +X_test = sc_X.transform(X_test) + + +# Ajustar el clasificador en el Conjunto de Training +# Crear aquí el modelo de Clasificación +# classifier + + +# Predicción de los resultados con el conjunto de Testing +y_pred = classifier.predict(X_test) + +# Elaborar una matriz de confusión +from sklearn.metrics import confusion_matrix +cm = confusion_matrix(y_test, y_pred) + +# Representación gráfica de los resultados del algoritmo +from matplotlib.colors import ListedColormap +X_set, y_set = X_train, y_train +X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01), + np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01)) +plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), + alpha = 0.75, cmap = ListedColormap(('red', 'green'))) +plt.xlim(X1.min(), X1.max()) +plt.ylim(X2.min(), X2.max()) +for i, j in enumerate(np.unique(y_set)): + plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1], + c = ListedColormap(('red', 'green'))(i), label = j) +plt.title('Clasificador (Conjunto de Training)') +plt.xlabel('Edad') +plt.ylabel('Sueldo Estimado') +plt.legend() +plt.show() + +# Representación gráfica de los resultados del algoritmo +from matplotlib.colors import ListedColormap +X_set, y_set = X_test, y_test +X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01), + np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01)) +plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), + alpha = 0.75, cmap = ListedColormap(('red', 'green'))) +plt.xlim(X1.min(), X1.max()) +plt.ylim(X2.min(), X2.max()) +for i, j in enumerate(np.unique(y_set)): + plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1], + c = ListedColormap(('red', 'green'))(i), label = j) +plt.title('Clasificador (Conjunto de Test)') +plt.xlabel('Edad') +plt.ylabel('Sueldo Estimado') +plt.legend() +plt.show() \ No newline at end of file diff --git a/datasets/Get the Machine Learning Basics/Data Preprocessing Template/.DS_Store b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/.DS_Store index 057b2ec7..e34e448d 100644 Binary files a/datasets/Get the Machine Learning Basics/Data Preprocessing Template/.DS_Store and b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/.DS_Store differ diff --git a/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/.Rhistory b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/.Rhistory new file mode 100644 index 00000000..3b9b67f2 --- /dev/null +++ b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/.Rhistory @@ -0,0 +1,95 @@ +print("Hello world!") +dataset = read.csv('Data.csv') +dataset = read.csv('Data.csv') +setwd("~/Dropbox/DigitalEmpathy/Nylvam/GitHub/deeplearning-az/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template") +dataset = read.csv('Data.csv') +View(dataset) +View(dataset) +dataset$Age = ifelse(is.na(datset$Age), +ave(dataset$Age, FUN = function(x) mean(x, na.rm = TRUE)), +dataset$Age) +dataset$Age = ifelse(is.na(dataset$Age), +ave(dataset$Age, FUN = function(x) mean(x, na.rm = TRUE)), +dataset$Age) +dataset$Salary = ifelse(is.na(dataset$Salary), +ave(dataset$Salary, FUN = function(x) mean(x, na.rm = TRUE)), +dataset$Salary) +# Codificar las variables categóricas +dataset$Country = factor(dataset$Country, +levels = c("France", "Spain", "Germnay"), +labels = c(1, 2, 3)) +dataset$Purchased = factor(dataset$Purchased, +levels = c("No", "Yes"), +labels = c(0, 1)) +# Dividir los datos en conjunto de training y conjunto de test +# install.packages("caTools") +library(caTools) +# Establecer un valor de semilla para la selección de datos +set.seed(123) +# Establecemos un 80% de las filas como ratio de división (training) +split = sample.split(dataset$Purchased, SplitRatio = 0.8) +training_set = subset(dataset, split = TRUE) +testing_set = subset(dataset, split = FALSE) +View(testing_set) +View(training_set) +View(testing_set) +View(dataset) +View(testing_set) +View(training_set) +View(dataset) +dataset = read.csv('Data.csv') +View(dataset) +# Tratamiento de los valores NA +dataset$Age = ifelse(is.na(dataset$Age), +ave(dataset$Age, FUN = function(x) mean(x, na.rm = TRUE)), +dataset$Age) +dataset$Salary = ifelse(is.na(dataset$Salary), +ave(dataset$Salary, FUN = function(x) mean(x, na.rm = TRUE)), +dataset$Salary) +# Codificar las variables categóricas +dataset$Country = factor(dataset$Country, +levels = c("France", "Spain", "Germany"), +labels = c(1, 2, 3)) +dataset$Purchased = factor(dataset$Purchased, +levels = c("No", "Yes"), +labels = c(0, 1)) +# Dividir los datos en conjunto de training y conjunto de test +# install.packages("caTools") +library(caTools) +# Establecer un valor de semilla para la selección de datos +set.seed(123) +# Establecemos un 80% de las filas como ratio de división (training) +split = sample.split(dataset$Purchased, SplitRatio = 0.8) +training_set = subset(dataset, split = TRUE) +testing_set = subset(dataset, split = FALSE) +View(training_set) +View(testing_set) +dataset = read.csv('Data.csv') +View(dataset) +dataset$Age = ifelse(is.na(dataset$Age), +ave(dataset$Age, FUN = function(x) mean(x, na.rm = TRUE)), +dataset$Age) +dataset$Salary = ifelse(is.na(dataset$Salary), +ave(dataset$Salary, FUN = function(x) mean(x, na.rm = TRUE)), +dataset$Salary) +# Codificar las variables categóricas +dataset$Country = factor(dataset$Country, +levels = c("France", "Spain", "Germany"), +labels = c(1, 2, 3)) +dataset$Purchased = factor(dataset$Purchased, +levels = c("No", "Yes"), +labels = c(0, 1)) +library(caTools) +# Establecer un valor de semilla para la selección de datos +set.seed(123) +split = sample.split(dataset$Purchased, SplitRatio = 0.8) +training_set = subset(dataset, split == TRUE) +testing_set = subset(dataset, split == FALSE) +View(training_set) +View(testing_set) +View(dataset) +training_set[,2:3] = scale(training_set[,2:3]) +testing_set[,2:3] = scale(testing_set[,2:3]) +View(dataset) +View(training_set) +View(testing_set) diff --git a/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_categorial_data.R b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_categorial_data.R new file mode 100644 index 00000000..d44b879a --- /dev/null +++ b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_categorial_data.R @@ -0,0 +1,12 @@ +# Plantilla para el Pre Procesado de Datos - Datos Categóricos + +# Importar el dataset +dataset = read.csv('Data.csv') + +# Codificar las variables categóricas +dataset$Country = factor(dataset$Country, + levels = c("France", "Spain", "Germany"), + labels = c(1, 2, 3)) +dataset$Purchased = factor(dataset$Purchased, + levels = c("No", "Yes"), + labels = c(0, 1)) diff --git a/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_categorial_data.py b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_categorial_data.py new file mode 100644 index 00000000..5f392670 --- /dev/null +++ b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_categorial_data.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Feb 5 18:22:43 2020 + +@author: ramonpuga +""" + +# Plantilla de Pre Procesado de Datos - Datos categóricos + +# Importar las librerias +import numpy as np +import matplotlib.pyplot as plt +import pandas as pd + +# Importar el dataset +dataset = pd.read_csv('Data.csv') +# Matriz X con todas las filas, y todas las columnas menos la última +X = dataset.iloc[:, :-1].values +# Vector y con todas las filas y la última columna +y = dataset.iloc[:, -1].values + +# Codificar datos de categorías +from sklearn.preprocessing import LabelEncoder +labelencoder_X = LabelEncoder() +# La columna 0 contine valores que son categorías +X[:, 0] = labelencoder_X.fit_transform(X[:, 0]) + +#El OneHotEncoder en las nuevas versiones está OBSOLETO + +# Convertimos esos valores en columnas dummy (tantas como categorías) +#onehotencoder = OneHotEncoder(categorical_features=[0]) +#X = onehotencoder.fit_transform(X).toarray() + +from sklearn.preprocessing import OneHotEncoder +from sklearn.compose import ColumnTransformer + +transformer = ColumnTransformer( + transformers=[ + ("Data_Modelling", # Un nombre de la transformación + OneHotEncoder(categories='auto'), # La clase a la que transformar + [0] # Las columnas a transformar. + ) + ], remainder='passthrough' +) + +X = transformer.fit_transform(X) +# Eliminar una columna dummy para evitar la multicolinealidad +# OneHotEncoder pone las columnas dummy al principio, por lo tanto habrá que elimnar la columna 0 +X = X[:, 1:] + + +# La columna de resultados, tambien es una categória (yes or no) +labelencoder_y = LabelEncoder() +y = labelencoder_y.fit_transform(y) \ No newline at end of file diff --git a/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_data_preprocessing_template.R b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_data_preprocessing_template.R new file mode 100644 index 00000000..44838205 --- /dev/null +++ b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_data_preprocessing_template.R @@ -0,0 +1,20 @@ +# Plantilla para el Pre Procesado de Datos + +# Importar el dataset +dataset = read.csv('Data.csv') +# Ejemplo de seleccionar un conjunto de datos del dataset original +# dataset = dataset[, 2:3] + +# Dividir los datos en conjunto de training y conjunto de test +# install.packages("caTools") +library(caTools) +# Establecer un valor de semilla para la selección de datos +set.seed(123) +# Establecemos un 80% de las filas como ratio de división (training) +split = sample.split(dataset$Purchased, SplitRatio = 0.8) +training_set = subset(dataset, split == TRUE) +testing_set = subset(dataset, split == FALSE) + +# Escalado de valores para las columnas 2 y 3 (2ª y 3ª) +# training_set[,2:3] = scale(training_set[,2:3]) +# testing_set[,2:3] = scale(testing_set[,2:3]) diff --git a/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_data_preprocessing_template.py b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_data_preprocessing_template.py new file mode 100644 index 00000000..63964f09 --- /dev/null +++ b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_data_preprocessing_template.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Feb 5 15:15:34 2020 + +@author: ramonpuga +""" + +# Plantilla de Pre Procesado de Datos + +# Importar las librerias +import numpy as np +import matplotlib.pyplot as plt +import pandas as pd + +# Importar el dataset +dataset = pd.read_csv('Data.csv') + +# Matriz X con todas las filas, y todas las columnas menos la última +X = dataset.iloc[:, :-1].values +# Vector y con todas las filas y la última columna +y = dataset.iloc[:, -1].values + +# Dividir el data set en conjunto de training y de test +from sklearn.model_selection import train_test_split +# Aplicamos un porcentaje del 20% (0.2) para el test y un valor de selección alatoria de 0 +X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0) + +# Escalado (estandarización o normalización) de variables +""" Quitar comillas iniciales y fianles cuando se necesite este código +from sklearn.preprocessing import StandardScaler +sc_X = StandardScaler() +# Aplicamos y fijamos el metodo de estandarización a todas las columnas X +X_train = sc_X.fit_transform(X_train) +# Aplicamos el mismo metodo de estandarización que para los datos de training +X_test = sc_X.transform(X_test) +""" \ No newline at end of file diff --git a/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_missing_data.R b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_missing_data.R new file mode 100644 index 00000000..ea2614e7 --- /dev/null +++ b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_missing_data.R @@ -0,0 +1,12 @@ +# Plantilla para el Pre Procesado de Datos - Datos faltantes + +# Importar el dataset +dataset = read.csv('Data.csv') + +# Tratamiento de los valores NA +dataset$Age = ifelse(is.na(dataset$Age), + ave(dataset$Age, FUN = function(x) mean(x, na.rm = TRUE)), + dataset$Age) +dataset$Salary = ifelse(is.na(dataset$Salary), + ave(dataset$Salary, FUN = function(x) mean(x, na.rm = TRUE)), + dataset$Salary) diff --git a/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_missing_data.py b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_missing_data.py new file mode 100644 index 00000000..4b27fe40 --- /dev/null +++ b/datasets/Get the Machine Learning Basics/Data Preprocessing Template/Data Preprocessing Template/my_missing_data.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Feb 5 18:22:44 2020 + +@author: ramonpuga +""" + +# Plantilla de Pre Procesado de Datos - Datos faltantes + +# Importar las librerias +import numpy as np +import matplotlib.pyplot as plt +import pandas as pd + +# Importar el dataset +dataset = pd.read_csv('Data.csv') +# Matriz X con todas las filas, y todas las columnas menos la última +X = dataset.iloc[:, :-1].values +# Vector y con todas las filas y la última columna +y = dataset.iloc[:, -1].values + +# Tratamiento de los NAs (datos vacíos) +from sklearn.preprocessing import Imputer +# Aplicamos estrategia de la media de la columna para rellenar valores vacíos (NaN) +imputer = Imputer(missing_values = "NaN", strategy = "mean", axis = 0) +# Ajustamos los valores de la columna 1 a la 2 (3 no incluida) +imputer = imputer.fit(X[:, 1:3]) +# Copiamos los valores a la matriz X +X[:, 1:3] = imputer.transform(X[:, 1:3]) \ No newline at end of file diff --git a/datasets/Part 1 - Artificial Neural Networks (ANN)/ann.py b/datasets/Part 1 - Artificial Neural Networks (ANN)/ann.py index bbf8e0ca..1e098dc8 100644 --- a/datasets/Part 1 - Artificial Neural Networks (ANN)/ann.py +++ b/datasets/Part 1 - Artificial Neural Networks (ANN)/ann.py @@ -52,6 +52,7 @@ ) X = transformer.fit_transform(X) +# Eliminar columna 0 para evitar la multicolinealidad X = X[:, 1:] # Dividir el data set en conjunto de entrenamiento y conjunto de testing diff --git a/datasets/Part 1 - Artificial Neural Networks (ANN)/my_ann.py b/datasets/Part 1 - Artificial Neural Networks (ANN)/my_ann.py new file mode 100644 index 00000000..e014353d --- /dev/null +++ b/datasets/Part 1 - Artificial Neural Networks (ANN)/my_ann.py @@ -0,0 +1,166 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Sun Apr 28 10:38:56 2019 + +@author: juangabriel +""" + +# Redes Neuronales Artificales + +# Instalar Theano +# pip install --upgrade --no-deps git+git://github.com/Theano/Theano.git + +# Instalar Tensorflow y Keras +# conda install -c conda-forge keras + +# Parte 1 - Pre procesado de datos + + +# Cómo importar las librerías +import numpy as np +import matplotlib.pyplot as plt +import pandas as pd + +# Importar el data set +dataset = pd.read_csv('Churn_Modelling.csv') + +X = dataset.iloc[:, 3:13].values +y = dataset.iloc[:, 13].values + +# Codificar datos categóricos +from sklearn.preprocessing import LabelEncoder +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]) + +#El OneHotEncoder en las nuevas versiones está OBSOLETO +#onehotencoder = OneHotEncoder(categorical_features=[1]) +#X = onehotencoder.fit_transform(X).toarray() + +from sklearn.preprocessing import OneHotEncoder +from sklearn.compose import ColumnTransformer + +transformer = ColumnTransformer( + transformers=[ + ("Churn_Modelling", # Un nombre de la transformación + OneHotEncoder(categories='auto'), # La clase a la que transformar + [1] # Las columnas a transformar. + ) + ], remainder='passthrough' +) + +X = transformer.fit_transform(X) +# Eliminar columna 0 para evitar la multicolinealidad +X = X[:, 1:] + +# Dividir el data set en conjunto de entrenamiento y conjunto de testing +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) + +# Escalado de variables +from sklearn.preprocessing import StandardScaler +sc_X = StandardScaler() +X_train = sc_X.fit_transform(X_train) +X_test = sc_X.transform(X_test) + + +# Parte 2 - Construir la RNA + +# Importar Keras y librerías adicionales +import keras +from keras.models import Sequential +from keras.layers import Dense +from keras.layers import Dropout + +# Inicializar la RNA +classifier = Sequential() + +# Añadir las capas de entrada y primera capa oculta +classifier.add(Dense(units = 6, kernel_initializer = "uniform", activation = "relu", input_dim = 11)) +# Evitar el overfitting, probar entre 0.1 y 0.5 no subir de 0.5 +classifier.add(Dropout(p = 0.1)) + +# Añadir la segunda capa oculta +classifier.add(Dense(units = 6, kernel_initializer = "uniform", activation = "relu")) +classifier.add(Dropout(p = 0.1)) + +# Añadir la capa de salida +classifier.add(Dense(units = 1, kernel_initializer = "uniform", activation = "sigmoid")) + +# Compilar la RNA +classifier.compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["accuracy"]) + +# Ajustamos la RNA al Conjunto de Entrenamiento +classifier.fit(X_train, y_train, batch_size = 10, epochs = 100) + + +# Parte 3 - Evaluar el modelo y calcular predicciones finales + +# Predicción de los resultados con el Conjunto de Testing +y_pred = classifier.predict(X_test) +# Convertir la probabilidad del conjunto de test en 0 o 1 +# Necesario para la matriz de confusión +# Vamos a estimar que para el banco el >50% es True y el resto Falso +y_pred = (y_pred>0.5) + +# Elaborar una matriz de confusión +from sklearn.metrics import confusion_matrix +cm = confusion_matrix(y_test, y_pred) +print((cm[0][0]+cm[1][1])/cm.sum()) + +## Parte 4 - Evaluar, mejorar y Ajustar la RNA + +### Evaluar la **RNA** +from keras.wrappers.scikit_learn import KerasClassifier +from sklearn.model_selection import cross_val_score + +def build_classifier(): + classifier = Sequential() + classifier.add(Dense(units = 6, kernel_initializer = "uniform", activation = "relu", input_dim = 11)) + classifier.add(Dense(units = 6, kernel_initializer = "uniform", activation = "relu")) + classifier.add(Dense(units = 1, kernel_initializer = "uniform", activation = "sigmoid")) + classifier.compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["accuracy"]) + return classifier + +classifier = KerasClassifier(build_fn = build_classifier, batch_size = 10, nb_epoch = 100) +accuracies = cross_val_score(estimator=classifier, X = X_train, y = y_train, cv = 10, n_jobs=-1, verbose = 1) + +mean = accuracies.mean() +variance = accuracies.std() +print(mean) +print(variance) + +### Mejorar la RNA +#### Regularización de Dropout para evitar el *overfitting* + +### Ajustar la *RNA* +from sklearn.model_selection import GridSearchCV # sklearn.grid_search + +# Nueva función con un parametro para el optimizador a utilizar en GridSearch +# Se podria dar un vaor por defecto --> def build_classifier(optimizer = 'adam'); +def build_classifier(optimizer): + classifier = Sequential() + classifier.add(Dense(units = 6, kernel_initializer = "uniform", activation = "relu", input_dim = 11)) + classifier.add(Dense(units = 6, kernel_initializer = "uniform", activation = "relu")) + classifier.add(Dense(units = 1, kernel_initializer = "uniform", activation = "sigmoid")) + # Se usa el parametro como optimizador + classifier.compile(optimizer = optimizer, loss = "binary_crossentropy", metrics = ["accuracy"]) + return classifier + +classifier = KerasClassifier(build_fn = build_classifier) + +parameters = { + 'batch_size' : [25,32], + 'nb_epoch' : [100, 500], + 'optimizer' : ['adam', 'rmsprop'] +} + +grid_search = GridSearchCV(estimator = classifier, + param_grid = parameters, + scoring = 'accuracy', + cv = 10) +grid_search = grid_search.fit(X_train, y_train) +best_parameters = grid_search.best_params_ +best_accuracy = grid_search.best_score_ diff --git a/datasets/Part 6 - AutoEncoders (AE)/autoencoder_kaggle.py b/datasets/Part 6 - AutoEncoders (AE)/autoencoder_kaggle.py new file mode 100644 index 00000000..10de0346 --- /dev/null +++ b/datasets/Part 6 - AutoEncoders (AE)/autoencoder_kaggle.py @@ -0,0 +1,111 @@ +# Auto Encoders +# -*- coding: utf-8 -*- +""" +Created on Fri Jan 10 09:51:46 2020 + +@author: juangabriel +""" + +# Importar las librerías +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +import torch.nn.parallel +import torch.optim as optim +import torch.utils.data +from torch.autograd import Variable + +# Importar el dataset +movies = pd.read_csv("ml-1m/movies.dat", sep = '::', header = None, engine = 'python', encoding = 'latin-1') +users = pd.read_csv("ml-1m/users.dat", sep = '::', header = None, engine = 'python', encoding = 'latin-1') +ratings = pd.read_csv("ml-1m/ratings.dat", sep = '::', header = None, engine = 'python', encoding = 'latin-1') + +# Preparar el conjunto de entrenamiento y elconjunto de testing +training_set = pd.read_csv("ml-100k/u1.base", sep = "\t", header = None) +training_set = np.array(training_set, dtype = "int") +test_set = pd.read_csv("ml-100k/u1.test", sep = "\t", header = None) +test_set = np.array(test_set, dtype = "int") + +# Obtener el número de usuarios y de películas +nb_users = int(max(max(training_set[:, 0]), max(test_set[:,0]))) +nb_movies = int(max(max(training_set[:, 1]), max(test_set[:, 1]))) + +# Convertir los datos en un array X[u,i] con usuarios u en fila y películas i en columna +def convert(data): + new_data = [] + for id_user in range(1, nb_users+1): + id_movies = data[:, 1][data[:, 0] == id_user] + id_ratings = data[:, 2][data[:, 0] == id_user] + ratings = np.zeros(nb_movies) + ratings[id_movies-1] = id_ratings + new_data.append(list(ratings)) + return new_data + +training_set = convert(training_set) +test_set = convert(test_set) + +# Convertir los datos a tensores de Torch +training_set = torch.FloatTensor(training_set) +test_set = torch.FloatTensor(test_set) + + +# Crear la arquitectura de la Red Neuronal +class SAE(nn.Module): + def __init__(self, ): + super(SAE, self).__init__() + self.fc1 = nn.Linear(nb_movies, 20) + self.fc2 = nn.Linear(20, 10) + self.fc3 = nn.Linear(10, 20) + self.fc4 = nn.Linear(20, nb_movies) + self.activation = nn.Sigmoid() + def forward(self, x): + x = self.activation(self.fc1(x)) + x = self.activation(self.fc2(x)) + x = self.activation(self.fc3(x)) + x = self.fc4(x) + return x + +sae = SAE() +criterion = nn.MSELoss() +optimizer = optim.RMSprop(sae.parameters(), lr = 0.01, weight_decay = 0.5) + +# Entrenar el SAE +nb_epoch = 200 +for epoch in range(1, nb_epoch+1): + train_loss = 0 + s = 0. + for id_user in range(nb_users): + input = Variable(training_set[id_user]).unsqueeze(0) + target = input.clone() + if torch.sum(target.data > 0) > 0: + output = sae.forward(input) + target.require_grad = False + output[target == 0] = 0 + loss = criterion(output, target) + # la media no es sobre todas las películas, sino sobre las que realmente ha valorado + mean_corrector = nb_movies/float(torch.sum(target.data > 0)+1e-10) + loss.backward() + train_loss += np.sqrt(loss.data*mean_corrector) ## sum(errors) / n_pelis_valoradas + s += 1. + optimizer.step() + print("Epoch: "+str(epoch)+", Loss: "+str(train_loss/s)) + +# Evaluar el conjunto de test en nuestro SAE +test_loss = 0 +s = 0. +for id_user in range(nb_users): + input = Variable(training_set[id_user]).unsqueeze(0) + target = Variable(test_set[id_user]).unsqueeze(0) + if torch.sum(target.data > 0) > 0: + output = sae.forward(input) + target.require_grad = False + output[target == 0] = 0 + loss = criterion(output, target) + # la media no es sobre todas las películas, sino sobre las que realmente ha valorado + mean_corrector = nb_movies/float(torch.sum(target.data > 0)+1e-10) + test_loss += np.sqrt(loss.data*mean_corrector) ## sum(errors) / n_pelis_valoradas + s += 1. +print("Test Loss: "+str(train_loss/s)) + +