<jupyter_start><jupyter_text>Importando as bibliotecas<jupyter_code>import tensorflow
from tensorflow import keras
import matplotlib.pyplot as plt
import numpy as np
from tensorflow.keras.models import load_model<jupyter_output><empty_output><jupyter_text>Carregando o dataset<jupyter_code>dataset = keras.datasets.fashion_mnist
((x_treino, y_treino),(x_teste,y_teste)) = dataset.load_data()<jupyter_output>Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 1s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 1s 0us/step<jupyter_text>Exploração dos dados<jupyter_code>len(x_treino)
len(x_teste)
x_treino.shape   #retorna a quantidade de elementos(imagens) da tupla, o numero de colunas, e o numero de linhas.
y_treino.min()
y_treino.max()<jupyter_output><empty_output><jupyter_text>Exibição dos dados<jupyter_code>total_classificacoes = 10
nomes_classificacao = ['camiseta', 'calça', 'pullover', 'vestido', 'casaco', 'sandália', 'camisa', 'tênis', 'bolsa', 'bota']

for imagem in range(10):
  plt.subplot(2,5, imagem+1)
  plt.imshow(x_treino[imagem])
  plt.title(nomes_classificacao[y_treino[imagem]])
plt.imshow(x_treino[0])
plt.colorbar()   # mostra a gradação das cores de 0 a 255 pixels<jupyter_output><empty_output><jupyter_text>Normalização<jupyter_code>x_treino = x_treino/float(255)  # em vez de passar 256 valores, passa valores decimais de 0 a 1<jupyter_output><empty_output><jupyter_text>Criando, Compilando e Treinando o modelo da RNA<jupyter_code># é usual contar o número de camadas sem levar em conta a de entrada, logo esse modelo teria 3 camadas apenas.
# ao tentar aumentar o numero de camadas ocultas aumentou o numero de perda(loss)
modelo = keras.Sequential([
                          keras.layers.Flatten(input_shape=(28,28)), # camada de entrada que achata os 28x28 pixels das imagens em uma array de 784 pixels
                          keras.layers.Dense(256, activation = tensorflow.nn.relu),  # 1° camada oculta com 256 neurônios, passando uma função de ativação ReLU (uma função não linear)
                          keras.layers.Dropout(0.2), # 2° camada oculta, deixa 'adormecido' uma porcentagem de neurônios da camada oculta, serve para normalizar
                          keras.layers.Dense(10, activation = tensorflow.nn.softmax) # camada de saída, com 10 neurônios que é equivalente ao total de classificações, e softmax como função de ativação
])

#lr: learning rate - taxa de aprendizado/ o padrão é 0.001
adam = keras.optimizers.Adam(lr = 0.002)
# com 0.5 fica com uma perda muito alta e acurácia muito baixa

# O EarlyStopping quando atinge um limite de um determinado parâmetro é parado mais cedo o treinamento, para não precisar percorrer todas as épocas
parando_cedo = [keras.callbacks.EarlyStopping(monitor = 'val_loss'),
                keras.callbacks.ModelCheckpoint(filepath = 'melhor_modelo_hdf5',
                                                 modelo = 'val_loss', save_best_only = True)]
# O ModelCheckpoint serve para salvar a configuração do melhor modelo


# compilando
modelo.compile(optimizer = adam, loss = 'sparse_categorical_crossentropy', metrics = ['accuracy']) # define os algoritmos do otimizador, do calculo do erro (perda), e da metrica de acerto.

# treinando 
historico = modelo.fit(x_treino, y_treino, batch_size = 480, epochs = 5, validation_split = 0.2, callbacks = parando_cedo) # treina, define o numero de épocas, e separa 20% para validação
# batch_size é quantidade de conjuntos treinados por vez, ajuda a diminuir o tempo de processamento<jupyter_output>Train on 48000 samples, validate on 12000 samples
Epoch 1/5
48000/48000 [==============================] - 2s 51us/sample - loss: 0.6569 - acc: 0.7686 - val_loss: 0.4511 - val_acc: 0.8444
Epoch 2/5
48000/48000 [==============================] - 2s 35us/sample - loss: 0.4391 - acc: 0.8453 - val_loss: 0.3998 - val_acc: 0.8589
Epoch 3/5
48000/48000 [==============================] - 2s 35us/sample - loss: 0.3907 - acc: 0.8601 - val_loss: 0.3816 - val_acc: 0.8609
Epoch 4/5
48000/48000 [==============================] - 2s 35us/sample - loss: 0.3657 - acc: 0.8688 - val_loss: 0.3570 - val_acc: 0.8702
Epoch 5/5
48000/48000 [==============================] - 2s 35us/sample - loss: 0.3403 - acc: 0.8766 - val_loss: 0.3448 - val_acc: 0.8780<jupyter_text>**OBS: Hiperparâmetros são todos os parâmetros que se pode ajustar antes de treinar o modelo, exemplos: num de camadas, num de neurônios, lr, batch_size, épocas, etc..Já os parâmetros são os pesos e bias.**<jupyter_code># retorna a configuração total do modelo
modelo.get_config()<jupyter_output><empty_output><jupyter_text>Sumário do Modelo<jupyter_code># resumo do modelo
sumario_modelo = modelo.summary()<jupyter_output>Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
flatten (Flatten)            (None, 784)               0         
_________________________________________________________________
dense (Dense)                (None, 256)               200960    
_________________________________________________________________
dropout (Dropout)            (None, 256)               0         
_________________________________________________________________
dense_1 (Dense)              (None, 10)                2570      
=================================================================
Total params: 203,530
Trainable params: 203,530
Non-trainable params: 0
_________________________________________________________________<jupyter_text>Pesos e Vieses(Bias)<jupyter_code># mostra os pesos da camada 1, que é a camada dense
# os pesos medem as características mais importantes do modelo
pesos_camada_dense = modelo.layers[1].get_weights()[0]
pesos_camada_dense
# mudando o índice de 0 para 1 passa a mostrar os vieses(bias) da mesma camada
# o bias mede a distância que falta para o resultado esperado
vieses_camada_dense = modelo.layers[1].get_weights()[1]
vieses_camada_dense<jupyter_output><empty_output><jupyter_text>**Obs: quando a rede esta errando os valores propagados serão recalculados e assim, por ter errado, o peso será diminuido e o viés aumentado, já que vai ter se afastado do resultado ideal.**  Salvando e Carregando o Modelo<jupyter_code>modelo.save('rna_alura.h5')  # salvar no formato h5
modelo_salvo = load_model('rna_alura.h5')<jupyter_output>WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/ops/init_ops.py:97: calling GlorotUniform.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.
Instructions for updating:
Call initializer instance with the dtype argument instead of passing it to the constructor
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/ops/init_ops.py:97: calling Zeros.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.
Instructions for updating:
Call initializer instance with the dtype argument instead of passing it to the constructor<jupyter_text>Gráfico do Histórico da Acurácia<jupyter_code>plt.plot(historico.history['acc'])
plt.plot(historico.history['val_acc'])
plt.title('Acurácia por Épocas')
plt.xlabel('Épocas')
plt.ylabel('Acurácia')
plt.legend(['Treino','Validação'])<jupyter_output><empty_output><jupyter_text>Gráfico do Histórico da Perda<jupyter_code>plt.plot(historico.history['loss'])
plt.plot(historico.history['val_loss'])
plt.title('Perda por Épocas')
plt.xlabel('Épocas')
plt.ylabel('Perda')
plt.legend(['Treino','Validação'])<jupyter_output><empty_output><jupyter_text>Testando o Modelo<jupyter_code>testes = modelo.predict(x_teste)
modelo.evaluate(x_teste,y_teste)<jupyter_output>10000/10000 [==============================] - 0s 41us/sample - loss: 65.5461 - acc: 0.8411<jupyter_text>Testando Com Pesos Zerados**Obs: Apenas para aprender, não vale a pena zera-los**<jupyter_code>pesos_camada_dense.shape
pesos_camada_dense_zerados = np.zeros((784, 256))

pesos_camada_dense_zerados
modelo.layers[1].set_weights([pesos_camada_dense_zerados, vieses_camada_dense])

modelo.layers[1].get_weights()
modelo.compile(optimizer='adam',loss='sparse_categorical_crossentropy', metrics = ['accuracy']) 

historico = modelo.fit(x_treino, y_treino, epochs = 5, validation_split = 0.2) 
plt.plot(historico.history['acc'])
plt.plot(historico.history['val_acc'])
plt.title('Acurácia por Épocas')
plt.xlabel('Épocas')
plt.ylabel('Acurácia')
plt.legend(['Treino','Validação'])
plt.plot(historico.history['loss'])
plt.plot(historico.history['val_loss'])
plt.title('Perda por Épocas')
plt.xlabel('Épocas')
plt.ylabel('Perda')
plt.legend(['Treino','Validação'])<jupyter_output><empty_output><jupyter_text>Testando com Valores Aleatórios nos Pesos**Obs: Apenas para aprender, não vale a pena deixa-los aleatórios**<jupyter_code>pesos_camada_dense_aleatorios = np.random.rand(784, 256)
pesos_camada_dense_aleatorios
modelo.layers[1].set_weights([pesos_camada_dense_aleatorios, vieses_camada_dense])

modelo.layers[1].get_weights()
modelo.compile(optimizer='adam',loss='sparse_categorical_crossentropy', metrics = ['accuracy']) 

historico = modelo.fit(x_treino, y_treino, epochs = 5, validation_split = 0.2) 
plt.plot(historico.history['acc'])
plt.plot(historico.history['val_acc'])
plt.title('Acurácia por Épocas')
plt.xlabel('Épocas')
plt.ylabel('Acurácia')
plt.legend(['Treino','Validação'])
plt.plot(historico.history['loss'])
plt.plot(historico.history['val_loss'])
plt.title('Perda por Épocas')
plt.xlabel('Épocas')
plt.ylabel('Perda')
plt.legend(['Treino','Validação'])<jupyter_output><empty_output><jupyter_text>Testanto com Pesos e Viéses Zerados/Aleatórios**Percebe-se que os pesos tem maior influência na rede**<jupyter_code>vieses_camada_dense.shape
vieses_camada_dense_zerados = np.zeros((256,))

modelo.layers[1].set_weights([pesos_camada_dense_aleatorios, vieses_camada_dense_zerados])

modelo.layers[1].get_weights()

modelo.compile(optimizer='adam',loss='sparse_categorical_crossentropy', metrics = ['accuracy']) 

historico = modelo.fit(x_treino, y_treino, epochs = 5, validation_split = 0.2) 
plt.plot(historico.history['acc'])
plt.plot(historico.history['val_acc'])
plt.title('Acurácia por Épocas')
plt.xlabel('Épocas')
plt.ylabel('Acurácia')
plt.legend(['Treino','Validação'])<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14600725952813068, 'fraction_numerical': 0.03838475499092559, 'mean_word_length': 5.703771289537713, 'pattern_counts': {'":': 0, '<': 60, '<?xml version=': 0, '>': 60, 'https://': 4, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '16', 'dir': 'jupyter-structured-clean-dedup', 'id': '153206', 'license': 'MIT', 'n_tokens_mistral': 4219, 'n_tokens_neox': 3789, 'n_words': 845, 'path': 'deep_learning_keras.ipynb', 'repo_name': 'paulovbpo/machine_learning_alura', 'size': '11020'}