def main():
iris_parameters = []
iris_species = []
with open('datasets/iris.csv', mode='r') as iris_file:
irises = list(csv.reader(iris_file))
rd.shuffle(irises) # get our lines of data in random order
for iris in irises:
parameters = [float(n) for n in iris[0:4]]
iris_parameters.append(parameters)
species = iris[4]
iris_species.append(species)
iris_parameters = np.array(iris_parameters)
normalizar(iris_parameters)
iris_species = np.array(iris_species).reshape(-1, 1)
print("\nTreinando...\n")
iris_network = Perceptron(taxa=0.2, ativacao="l_relu", N=[4], debug=1)
# número de dados de treino
n_train = 120
# train over the first 140 irises in the data set 50 times
x_train = iris_parameters[:n_train]
y_train = iris_species[:n_train]
iris_network.treinar(x_train, y_train, M=100)
y_train_pred = iris_network.prever(x_train)
scores = Scores(y_train, y_train_pred)
scores.exibir_grafico()
# test over the last 10 of the irises in the data set
x_test = iris_parameters[n_train:]
y_test = iris_species[n_train:]
y_test_pred = iris_network.prever(x_test)
# minha classe geradora da matriz de confusão
scores = Scores(y_test, y_test_pred)
scores.exibir_grafico()
# assim o tipo de rede é definido pelo tipo da conexão dos neurônios
# e o mesmo tipo pode ser treinado de formas diferentes, mas
# mesmo assim usando esse formato de conexão
# "adam" é outro tipo de otimização, diferente do SGD
model.compile(optimizer="adam", loss='sparse_categorical_crossentropy', metrics=['accuracy'])
print("\nTreinando...\n")
model.fit(x_train, y_train, epochs=20)
# avaliando dados de treinamento
print("\navaliando dados de treinamento")
model.evaluate(x_train, y_train, verbose=2)
# avaliando os dados de teste
print("\navaliando os dados de teste")
model.evaluate(x_test, y_test, verbose=2)
# prevendo a partir dos dados de teste
y_train_pred = np.argmax(model.predict(x_train), axis=-1)
y_test_pred = np.argmax(model.predict(x_test), axis=-1)
# usando a minha classe de validação que mostra a matriz de confusão
score_train = Scores(y_train, y_train_pred)
score_train.exibir_grafico("Dados de treino")
score_test = Scores(y_test, y_test_pred)
score_test.exibir_grafico("Dados de teste")
print("Obtendo dados...")
mnist = load_digits() # versao 8x8
#mnist = fetch_openml('mnist_784', version=1) # versao 28x28
_N = int(mnist.data.shape[0] * 0.8)
x_train, y_train = mnist.data[:_N], mnist.target[:_N].astype(np.uint8)
x_test, y_test = mnist.data[_N:], mnist.target[_N:].astype(np.uint8)
# deixando os vetores nos formatos corretos pra usar no keras
y_train = y_train.reshape(-1, 1)
y_test = y_test.reshape(-1, 1)
normalizar(x_train)
normalizar(x_test)
perceptron = Perceptron(taxa=0.001, ativacao="elu", N=[48, 24])
print("\nTreinando...\n")
perceptron.treinar(x_train, y_train, M=20)
y_train_pred = perceptron.prever(x_train)
score = Scores(y_train, y_train_pred)
score.exibir_grafico("Dados de treino")
#mse = perceptron.funcao_erro(x_train, y_train)
#print("Mse do treino: %f"%mse)
y_test_pred = perceptron.prever(x_test)
score = Scores(y_test, y_test_pred)
score.exibir_grafico("Dados de teste")
#mse = perceptron.funcao_erro(x_test, y_test)
#print("Mse do teste: %f"%mse)