import numpy as np

import pandas as pd

from scipy import ndimage

from scipy import misc

from sklearn.preprocessing import LabelEncoder

from sklearn.preprocessing import StandardScaler

from sklearn.model_selection import StratifiedShuffleSplit

from matplotlib import pyplot as plt

train = pd.read_csv('train.csv')

test = pd.read_csv('test.csv')

img_dir = 'images/'

n_images = 1584

rows = int(467*0.2)

cols = int(526*0.2)

def encode(train, test):

return train, labels, test, classes

def load_image_data():

return img_data, np.array(_2d_images)

train, labels, test, classes = encode(train, test)

train = train.values

img_data, _2d_images = load_image_data()

##plt.imshow(_2d_images[0])#, interpolation='nearest')

##plt.show()

#img_data = np.array(img_data)

##img_data = img_data.reshape(1584, rows,cols)

##print("data loaded")

##input()

# splittrain data into train and validation

sss = StratifiedShuffleSplit(test_size=0.2, random_state=23)

for train_index, valid_index in sss.split(train, labels):

X_train, X_valid = train[train_index], train[valid_index]

y_train, y_valid = labels[train_index], labels[valid_index]

X_train_img, X_valid_img = img_data[train_index], img_data[valid_index]

X_train_2dimg, X_valid_2dimg = _2d_images[train_index], _2d_images[valid_index]

X_test = test.values

print("Done")

import keras

from keras.datasets import mnist

from keras.models import Sequential

from keras.layers import Dense, Dropout, Flatten

from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D

from keras import backend as K

from keras.callbacks import ReduceLROnPlateau, EarlyStopping

batch_size = 1

num_classes = len(classes)

epochs = 20

img_rows, img_cols = rows, cols #dimensões das imagens

X_train_2dimg = X_train_2dimg.reshape(X_train_2dimg.shape[0], img_rows, img_cols, 1) #ajustando o tamanho da matriz de treino

X_valid_2dimg = X_valid_2dimg.reshape(X_valid_2dimg.shape[0], img_rows, img_cols, 1) #ajustando o tamanho da matriz de teste

input_shape = (img_rows, img_cols, 1) #definindo o tamanho da entrada da rede

X_train_2dimg = X_train_2dimg.astype('float32') #transformando os píxels das imagens em floats

X_valid_2dimg = X_valid_2dimg.astype('float32') #transformando os píxels das imagens em floats

y_train = keras.utils.to_categorical(y_train, num_classes) #convertendo as classes em vetores binários (one hot encoding)

y_valid = keras.utils.to_categorical(y_valid, num_classes)

model = Sequential() #Criando o modelo

model.add(Conv2D(32, (3, 3), activation='relu', input_shape=input_shape)) #Camada de convolução 2d, com janela 3x3, e Adcionando a ativação relu.

model.add(Conv2D(64, (3, 3), activation='relu')) #Camada de convolução 2d, com janela 3x3, e Adcionando a ativação relu.

model.add(AveragePooling2D(pool_size=(2, 2))) #Camada de Pooling 2d, de tamanho 2x2, através da média. (Retira a média aritmética de janelas 2x2 na imagem, reduzindo a quantidade de características 4->1 por janela)

model.add(Dropout(0.25)) #Camada de Dropout para evitar overfitting. Nada mais é do que desativar um neurônio. No caso a probabilidade de que isso seja feita é de 0.25, no exemplo em questão.

model.add(Flatten()) #Reduz a dimensão da camada. output_shape == (None, 64, 32, 32) -> Flatten() -> output_shape == (None, 65536)

model.add(Dense(128, activation='relu')) #Camada completamente conectada

model.add(Dense(num_classes, activation='softmax')) #Camada de saída, com ativação softmax.

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# monitores para o treinamento da rede

#https://keras.io/callbacks/

#Reduz a taxa de aprendizado

reduce_lr = ReduceLROnPlateau(monitor='val_loss', #observar a função de perda no conjunto de validação

min_lr=0.0001) #limite inferior da nova_taxa. Menor que isso e o monitor não irá reduzir mais a taxa.

#Interrompe o treinamento

early_stopping=EarlyStopping(monitor='val_loss', #observar a função de perda no conjunto de validação

patience=4, # número de épocas, sem redução na função de perda, que o monitor espera para agir.

verbose=1,)

#fazendo uso dos monitores criados

model.fit(X_train_2dimg, y_train, batch_size=batch_size, epochs=epochs, callbacks=[reduce_lr, early_stopping], verbose=1, validation_data=(X_valid_2dimg, y_valid))

loss, accuracy = model.evaluate(X_valid_2dimg, y_valid, verbose=0)

print('Test accuracy:', accuracy)

p = model.predict(X_valid_2dimg)