Permite importar archivos desde Google Drive


In [0]:
from google.colab import drive
drive.mount('/content/drive')


Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).

Importar librerías


In [0]:
import numpy as np
import pandas as pd
import matplotlib
#%matplotlib inline
import matplotlib.pyplot as plt

import matplotlib.cm as cm
from skimage import io, img_as_float
import scipy.interpolate as itp

import random

In [0]:
from __future__ import print_function
from time import time

from sklearn import metrics
from sklearn.cluster import KMeans
from sklearn.cluster import DBSCAN
from sklearn.cluster import AgglomerativeClustering
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.preprocessing import scale

from warnings import simplefilter

simplefilter(action='ignore', category=FutureWarning) # Comando para ignorar los warnings


import keras  # Importando la libreria keras
from keras.models import Sequential  
from keras.layers import Dense, Dropout, Flatten # Comandos de keras que importan las capas dense, dropout y flatten
from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D # Comandos de keras que importan las capas convolucionales y maxpooling2D
from keras import backend as K
from keras.layers.advanced_activations import LeakyReLU


Using TensorFlow backend.

Cargar base de datos


In [0]:
# Cargando base de datos Alerce.
data = pd.read_pickle('/content/drive/My Drive/Supernova/ALERCE_stamps.pkl') # Base de datos original
#data = pd.read_pickle('/content/drive/My Drive/Supernova/ALERCE_stamps_1k.pkl') # Base de datos reducida

In [0]:
imgs = data['images'] # Lista de 31727 imagenes
labels = data['labels'] # Lista de 31727 labels

img_0 = imgs[0] # Primera imagen de imgs, ndarray 63x63, 3 canales
label_0 = labels[0] # Primer label, entero

In [0]:
np.shape(imgs)


Out[0]:
(31727,)

Desechar imágenes no cuadradas


In [0]:
shap_def = (63, 63, 3) # Estructura correcta de imagenes, cuadradas, 3 canales

img_sq = [] # Inicializar lista vacia para almacenar imagenes que tienen
            # estructura correcta
label_sq = [] # Inicializar lista vacia para almacenar labels de imagenes que
              # tienen estructura correcta
    
for j in list(range(len(imgs))): # recorrer imagenes
    #print('Revisando si la imagen '+str(j)+' es cuadrada')
    if np.shape(imgs[j]) == shap_def: # si tiene estructura correcta, agregar
        
        img_sq.append(imgs[j])
        label_sq.append(labels[j])

Normalizar


In [0]:
img_sq = np.asarray(img_sq)
label_sq = np.asarray(label_sq)

# Funcion auxiliar que normaliza UNA matriz
def Norm_Data_matrix(matrix):
    max_data = np.nanmax(matrix)
    min_data = np.nanmin(matrix)
    Norm_matrix = (matrix-min_data)/(max_data-min_data)
    return Norm_matrix

# Normalizacion de las imagenes
img_norm = []
for i in range(len(img_sq)):
    muestra = img_sq[i]
    #print('Normalizando muestra ' + str(i))
    muestra[:, :, 0] = Norm_Data_matrix(muestra[:, :, 0])
    muestra[:, :, 1] = Norm_Data_matrix(muestra[:, :, 1])
    muestra[:, :, 2] = Norm_Data_matrix(muestra[:, :, 2])
    img_norm.append(muestra)

In [0]:
img_norm = np.array(img_norm) # Convertir a arreglo numpy

nan_index = np.argwhere(np.isnan(img_norm))
#print('Indices de nan en arreglo normalizado', nan_index)

img_no_nan = np.nan_to_num(img_norm) # Convertir nan a cero

nonan_index = np.argwhere(np.isnan(img_no_nan))
#print('Indices de nan en arreglo al eliminar nan', nonan_index)

In [0]:
np.shape(img_no_nan) # Dimensiones de la base corregida


Out[0]:
(31228, 63, 63, 3)

Balance de Clases, definir conjuntos de train, val, y test


In [0]:
"Objetos a tratar"

" Clases = {0: 'AGN', 1:'SN', 2:'VS', 3:'asteroid', 4:'bogus'}" 
"AGN: Active Galactic Nuclei"
"SN: Supernova"
"VS: Variable Star"
"bogus: Artifacts"

img_no_nan # imagenes, np array
label_sq # labels, np array

unique, counts = np.unique(label_sq, return_counts=True)
class_counter = dict(zip(unique, counts)) # muestra cuantas veces se repite cada clase
print('Numero de muestras por clase:', class_counter)

#test = np.concatenate((img_no_nan, label_sq), axis=0)
#test_1 = np.concatenate((img_no_nan, label_sq), axis=1)

s_index = np.arange(label_sq.shape[0]) # indexar arreglos

np.random.shuffle(s_index) # revolver

# label_sq.shape[0], label_sq.shape

img_no_nan = img_no_nan[s_index] # reemplazar arreglos originales por arreglos revueltos
label_sq = label_sq[s_index]

"Encontrar ubicaciones de todos los tipos de objeto"

agn_ind = np.squeeze(np.argwhere(label_sq == 0))
sn_ind = np.squeeze(np.argwhere(label_sq == 1))
vs_ind = np.squeeze(np.argwhere(label_sq == 2))
ast_ind = np.squeeze(np.argwhere(label_sq == 3))
bog_ind = np.squeeze(np.argwhere(label_sq == 4))

"Una lista para cada tipo de objeto"

img_AGN = img_no_nan[agn_ind]
img_SN = img_no_nan[sn_ind]
img_VS = img_no_nan[vs_ind]
img_AST = img_no_nan[ast_ind]
img_bog = img_no_nan[bog_ind]


Numero de muestras por clase: {0: 8721, 1: 987, 2: 9772, 3: 9797, 4: 1951}
[0 0 0 ... 0 0 0]
[ True  True  True ...  True  True  True]

In [0]:
# Separación de la base de datos en un conjunto de entrenamiento y validación.
train_size = int(len(img_no_nan)*.75) # Definiendo el tamaño del conjunto de entrenamiento con los requisitos solicitados 
train_total = int(len(img_no_nan)) # Tamaño total del conjunto original.
x_train = img_no_nan[0:train_size,:] # Nuevo conjunto horizontal de entrenamiento.
x_val = img_no_nan[train_size:train_total,:] # Conjunto de validacion horizontal. (imagenes)
y_train = y_data[:train_size] # Nuevo conjunto vertical de entrenamiento. (clases)
y_val = y_data[train_size:] # Conjunto de validacion vertical (clases)

input_shape = (img_rows, img_cols, 3)

Red Neuronal

Preliminares


In [0]:
# Para poder procesar las clases es necesario pasarlas a one hot encoding

# Funcion para tener las clases como one hot encoding
def one_hot(a, num_classes):
    return np.squeeze(np.eye(num_classes)[a.reshape(-1)])

In [0]:
onehot_labels = one_hot(label_sq, 5)

In [0]:
batch_size = 128 # Definiendo el tamaño de los batches
num_classes = 5 # Numero de clases del conjunto
epochs = 12 # Cantidad de epocas
#pool_value = 0.5

In [0]:
# input image dimensions
img_rows, img_cols = 63, 63  # Definiendo las filas y columnas de las imagenes
y_data = onehot_labels

In [0]:
np.shape(img_no_nan)


Out[0]:
(31228, 63, 63, 3)

Al parecer este bloque no hace nada a las variables x_train y similares


In [0]:
x_train = x_train.astype('float32')
x_val = x_val.astype('float32')
x_train /= 255
x_val /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_val.shape[0], 'test samples')


x_train shape: (23421, 63, 63, 3)
23421 train samples
7807 test samples

Configurar Red!


In [0]:
""" PROGRAMACIÓN DE LA RED NEURONAL CONVOLUCIONAL!!
    En los siguientes bloques se configura una CNN usando la estructura entregada en el paper.
"""


"Convierten a one hot encoding"
y_train_1 = keras.utils.to_categorical(y_train, num_classes) # Categorización de las muestras del conjunto vertical de entrenamiento.
y_val_1 = keras.utils.to_categorical(y_val, num_classes) # Categorización de las muestras del conjunto vertical de prueba.
"Convierten a one hot encoding"


time_i = time()
model = Sequential() # Inicio de la configuracion del clasificador , a partir de este punto se le añadiran las capas que conformaran la CNN
model.add(Conv2D(32, kernel_size=(4, 4), # Añadiendo una capa convolucional al modelo con un kernel  de 3x3 
                 activation = None, # Con un funcion de activacion relu  y las dimensiones configuradas en el bloque anterior
                 input_shape=input_shape)) 
model.add(Conv2D(32, (3, 3), activation = None)) # Añadiendo otra capa convolucional  con una funcion de activacion relu
model.add(MaxPooling2D(pool_size=(2, 2),strides = 2)) # Utilizando el método maxpooling en esta red.
model.add(Conv2D(64, (3, 3), activation = None))
model.add(Conv2D(64, (3, 3), activation = None))
model.add(Conv2D(64, (3, 3), activation = None))
model.add(MaxPooling2D(pool_size=(2, 2), strides = 2))
#model.add(Dropout(0.5)) # Añadiendo Dropout a la red
model.add(Flatten()) # Este comando remueve todas las dimensiones de un tensor exceptuano una.
#model.add(Dense(128, activation=LeakyReLU)) # En esta capa se implementa la funcion de activacion relu a la capa anterior de la la red neuronal. 
model.add(Dense(64)) # 64 salidas
model.add(LeakyReLU()) # LeakyReLU
model.add(Dropout(0.5)) # Se agrega la tecnica de Dropout para abordar el overfitting.
model.add(Dense(64))
model.add(LeakyReLU()) # LeakyReLU
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax')) # Se aplica a la red siendo esta vez usando la funcion softmax.

model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy']) # Con este coomando se configura el modelo para el entrenamiento.


WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:66: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:541: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4432: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:4267: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:148: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3733: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.
Instructions for updating:
Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/optimizers.py:793: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.

WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py:3576: The name tf.log is deprecated. Please use tf.math.log instead.

Entrenamiento


In [0]:
# Entrenamiento del modelo

model_train = model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1,
          validation_data=(x_val, y_val)) # Comando para entrenar el modelo.
model_train
score = model.evaluate(x_val, y_val, verbose=0) # Con este comando se obtiene el valor de perdida y de las metricas en el modo de prueba.
time_f = time()
time_execution = time_f - time_i # Con este comando se obtiene el valor de perdida y de las metricas en el modo de prueba.
print('Valid loss:', score[0]) # Se imprime la perdida para la prueba realizada.
print('Valid accuracy:', score[1]) # Se imprimre el accuracy para la prueba realizada.
print('Tiempo de entrenamiento ' + str(time_execution))


WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.where in 2.0, which has the same broadcast rule as np.where
Train on 23421 samples, validate on 7807 samples
Epoch 1/12
 7296/23421 [========>.....................] - ETA: 24s - loss: 1.4488 - acc: 0.3076
---------------------------------------------------------------------------
KeyboardInterrupt                         Traceback (most recent call last)
<ipython-input-28-f6a3fdf4865c> in <module>()
      4           epochs=epochs,
      5           verbose=1,
----> 6           validation_data=(x_val, y_val)) # Comando para entrenar el modelo.
      7 model_train
      8 score = model.evaluate(x_val, y_val, verbose=0) # Con este comando se obtiene el valor de perdida y de las metricas en el modo de prueba.

/usr/local/lib/python3.6/dist-packages/keras/engine/training.py in fit(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_freq, max_queue_size, workers, use_multiprocessing, **kwargs)
   1176                                         steps_per_epoch=steps_per_epoch,
   1177                                         validation_steps=validation_steps,
-> 1178                                         validation_freq=validation_freq)
   1179 
   1180     def evaluate(self,

/usr/local/lib/python3.6/dist-packages/keras/engine/training_arrays.py in fit_loop(model, fit_function, fit_inputs, out_labels, batch_size, epochs, verbose, callbacks, val_function, val_inputs, shuffle, callback_metrics, initial_epoch, steps_per_epoch, validation_steps, validation_freq)
    202                     ins_batch[i] = ins_batch[i].toarray()
    203 
--> 204                 outs = fit_function(ins_batch)
    205                 outs = to_list(outs)
    206                 for l, o in zip(out_labels, outs):

/usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py in __call__(self, inputs)
   2977                     return self._legacy_call(inputs)
   2978 
-> 2979             return self._call(inputs)
   2980         else:
   2981             if py_any(is_tensor(x) for x in inputs):

/usr/local/lib/python3.6/dist-packages/keras/backend/tensorflow_backend.py in _call(self, inputs)
   2935             fetched = self._callable_fn(*array_vals, run_metadata=self.run_metadata)
   2936         else:
-> 2937             fetched = self._callable_fn(*array_vals)
   2938         return fetched[:len(self.outputs)]
   2939 

/usr/local/lib/python3.6/dist-packages/tensorflow/python/client/session.py in __call__(self, *args, **kwargs)
   1456         ret = tf_session.TF_SessionRunCallable(self._session._session,
   1457                                                self._handle, args,
-> 1458                                                run_metadata_ptr)
   1459         if run_metadata:
   1460           proto_data = tf_session.TF_GetBuffer(run_metadata_ptr)

KeyboardInterrupt: 

In [0]:
import numpy as np

x = np.array([0, 3, 1, 2, 4, 1, 0, 4])
# x = np.reshape(x, (4, 25))
print(x)


ind = np.squeeze(np.argwhere(x%7 == 0))
print(ind)

#y = np.squeeze(x[ind])
y = x[ind]
print(y)

z = keras.utils.to_categorical(x, 5)

print(z)


[0 3 1 2 4 1 0 4]
[0 6]
[0 0]
[[1. 0. 0. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 0. 1.]
 [0. 1. 0. 0. 0.]
 [1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1.]]