Neural Networks

En el siguiente ejercicio de neural networks vamos a utilizar la librería scikit-learn, si aún no cuentas con esta librería en tu computadora te recomiendo usar el siguiente comando en la anaconda-promt:

conda install scikit-learn

Para mayor información en cuanto a la instalación puedes visitar el siguiente link documentación

¿Qué es una neural network?

Las redes neuronales son un marco de aprendizaje automático que intenta imitar el patrón de aprendizaje de las redes neuronales biológicas naturales. Las redes neuronales biológicas tienen neuronas interconectadas con dendritas que reciben entradas, y luego, a partir de estas entradas, producen una señal de salida a través de un axón a otra neurona. Trataremos de imitar este proceso mediante el uso de Redes neuronales artificiales (ANN), que a partir de ahora llamaremos redes neuronales. El proceso de crear una red neuronal comienza con la forma más básica, un solo perceptrón

¿Qué es un perceptrón?

Un perceptron tiene una o más entradas, un sesgo, una función de activación y una única salida. El perceptron recibe entradas, las multiplica por un poco de peso y luego las pasa a una función de activación para producir una salida. Hay muchas funciones de activación posibles para elegir, como la función logística, una función trigonométrica, una función de paso, etc. También nos aseguramos de agregar un sesgo al perceptrón, esto evita problemas donde todas las entradas podrían ser iguales a cero (es decir, ningún peso multiplicativo tendría un efecto).

Una vez que tenemos el resultado, podemos compararlo con una etiqueta conocida y ajustar los pesos en consecuencia (los pesos usualmente comienzan con valores de inicialización aleatorios). Seguimos repitiendo este proceso hasta que hayamos alcanzado un número máximo de iteraciones permitidas, o una tasa de error aceptable.

Para crear una red neuronal, simplemente comenzamos a agregar capas de perceptrones, creando un modelo de perceptrón multicapa de una red neuronal. Tendrás una capa de entrada que tomará directamente tus entradas de funciones y una capa de salida que creará las salidas resultantes. Las capas intermedias se conocen como capas ocultas porque no "ven" directamente las entradas o salidas de características.

Tenga en cuenta que, debido a su naturaleza, las redes neuronales tienden a funcionar mejor en la GPU que en la CPU. El marco de aprendizaje de sci-kit no está diseñado para la optimización de GPU. Si desea continuar con la GPU y los modelos distribuidos, eche un vistazo a otros marcos, como el TensforFlow de fuente abierta de Google.

Información

Para este análisis, abordaremos la información que se tiene disponible en el módulo de SciKit Learn sobre el Cancer de pecho. Vamos a intentar crear una neural network capaz de predecir si el tumor es maligno o benigno


In [3]:
# librerís
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()

In [4]:
data.keys()


Out[4]:
dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])

In [7]:
# imprimir la descripción completa de la información
print(data['DESCR'])


Breast Cancer Wisconsin (Diagnostic) Database
=============================================

Notes
-----
Data Set Characteristics:
    :Number of Instances: 569

    :Number of Attributes: 30 numeric, predictive attributes and the class

    :Attribute Information:
        - radius (mean of distances from center to points on the perimeter)
        - texture (standard deviation of gray-scale values)
        - perimeter
        - area
        - smoothness (local variation in radius lengths)
        - compactness (perimeter^2 / area - 1.0)
        - concavity (severity of concave portions of the contour)
        - concave points (number of concave portions of the contour)
        - symmetry 
        - fractal dimension ("coastline approximation" - 1)

        The mean, standard error, and "worst" or largest (mean of the three
        largest values) of these features were computed for each image,
        resulting in 30 features.  For instance, field 3 is Mean Radius, field
        13 is Radius SE, field 23 is Worst Radius.

        - class:
                - WDBC-Malignant
                - WDBC-Benign

    :Summary Statistics:

    ===================================== ====== ======
                                           Min    Max
    ===================================== ====== ======
    radius (mean):                        6.981  28.11
    texture (mean):                       9.71   39.28
    perimeter (mean):                     43.79  188.5
    area (mean):                          143.5  2501.0
    smoothness (mean):                    0.053  0.163
    compactness (mean):                   0.019  0.345
    concavity (mean):                     0.0    0.427
    concave points (mean):                0.0    0.201
    symmetry (mean):                      0.106  0.304
    fractal dimension (mean):             0.05   0.097
    radius (standard error):              0.112  2.873
    texture (standard error):             0.36   4.885
    perimeter (standard error):           0.757  21.98
    area (standard error):                6.802  542.2
    smoothness (standard error):          0.002  0.031
    compactness (standard error):         0.002  0.135
    concavity (standard error):           0.0    0.396
    concave points (standard error):      0.0    0.053
    symmetry (standard error):            0.008  0.079
    fractal dimension (standard error):   0.001  0.03
    radius (worst):                       7.93   36.04
    texture (worst):                      12.02  49.54
    perimeter (worst):                    50.41  251.2
    area (worst):                         185.2  4254.0
    smoothness (worst):                   0.071  0.223
    compactness (worst):                  0.027  1.058
    concavity (worst):                    0.0    1.252
    concave points (worst):               0.0    0.291
    symmetry (worst):                     0.156  0.664
    fractal dimension (worst):            0.055  0.208
    ===================================== ====== ======

    :Missing Attribute Values: None

    :Class Distribution: 212 - Malignant, 357 - Benign

    :Creator:  Dr. William H. Wolberg, W. Nick Street, Olvi L. Mangasarian

    :Donor: Nick Street

    :Date: November, 1995

This is a copy of UCI ML Breast Cancer Wisconsin (Diagnostic) datasets.
https://goo.gl/U2Uwz2

Features are computed from a digitized image of a fine needle
aspirate (FNA) of a breast mass.  They describe
characteristics of the cell nuclei present in the image.

Separating plane described above was obtained using
Multisurface Method-Tree (MSM-T) [K. P. Bennett, "Decision Tree
Construction Via Linear Programming." Proceedings of the 4th
Midwest Artificial Intelligence and Cognitive Science Society,
pp. 97-101, 1992], a classification method which uses linear
programming to construct a decision tree.  Relevant features
were selected using an exhaustive search in the space of 1-4
features and 1-3 separating planes.

The actual linear program used to obtain the separating plane
in the 3-dimensional space is that described in:
[K. P. Bennett and O. L. Mangasarian: "Robust Linear
Programming Discrimination of Two Linearly Inseparable Sets",
Optimization Methods and Software 1, 1992, 23-34].

This database is also available through the UW CS ftp server:

ftp ftp.cs.wisc.edu
cd math-prog/cpo-dataset/machine-learn/WDBC/

References
----------
   - W.N. Street, W.H. Wolberg and O.L. Mangasarian. Nuclear feature extraction 
     for breast tumor diagnosis. IS&T/SPIE 1993 International Symposium on 
     Electronic Imaging: Science and Technology, volume 1905, pages 861-870,
     San Jose, CA, 1993.
   - O.L. Mangasarian, W.N. Street and W.H. Wolberg. Breast cancer diagnosis and 
     prognosis via linear programming. Operations Research, 43(4), pages 570-577, 
     July-August 1995.
   - W.H. Wolberg, W.N. Street, and O.L. Mangasarian. Machine learning techniques
     to diagnose breast cancer from fine-needle aspirates. Cancer Letters 77 (1994) 
     163-171.


In [8]:
# estructura de la información
data['data'].shape


Out[8]:
(569, 30)

In [12]:
# configurar nuestra información y etiquetas
X = data['data']
y = data['target']

Train Test Split

Generar nuestra información para entreanimiento y prueba


In [16]:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y)

Preprocesamiento de la información

La red neuronal puede tener dificultades para converger antes de la cantidad máxima de iteraciones permitidas si los datos no están normalizados. El Perceptron multicapa es sensible a las incrustaciones de características, por lo que es muy recomendable escalar sus datos. Tenga en cuenta que debe aplicar la misma escala al conjunto de prueba para obtener resultados significativos. Hay muchos métodos diferentes para la normalización de los datos, utilizaremos el StandardScaler incorporado para la estandarización.


In [17]:
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
# ajustar la información de prueba
scaler.fit(X_train)


Out[17]:
StandardScaler(copy=True, with_mean=True, with_std=True)

In [18]:
# aplicar la transformación a la información
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Entrenamiento del modelo

Ahora entrenaremos nuestro modelo, el módulo SciKit Learn hace esta tarea muy fácil, con el uso de el estimador de objetos, en este caso particular importaremos nuestro estimador (Multi-Layer Perceptron Classifier model) from the neural_network library of SciKit-Learn


In [19]:
from sklearn.neural_network import MLPClassifier

In [20]:
mlp = MLPClassifier(hidden_layer_sizes=(30,30,30))

In [21]:
# ahora que tenemos el modelo generardo, ya podemos ajustar la información al modelo
mlp.fit(X_train,y_train)


Out[21]:
MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=(30, 30, 30), learning_rate='constant',
       learning_rate_init=0.001, max_iter=200, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=None,
       shuffle=True, solver='adam', tol=0.0001, validation_fraction=0.1,
       verbose=False, warm_start=False)

Predicciones y Evaluación

Ya que tenemos nuestro modelo, podemos realizar predicciones.


In [23]:
predictions = mlp.predict(X_test)

In [24]:
from sklearn.metrics import classification_report,confusion_matrix
print(confusion_matrix(y_test,predictions))


[[49  0]
 [ 4 90]]

In [25]:
print(classification_report(y_test,predictions))


             precision    recall  f1-score   support

          0       0.92      1.00      0.96        49
          1       1.00      0.96      0.98        94

avg / total       0.97      0.97      0.97       143


In [ ]: