Regressão Logística com TensorFlow e Keras

Packt_Pub Blocked Unblock Seguir Seguindo 10 de janeiro

Aprenda a regressão logística com TensorFlow e Keras neste artigo de Armando Fandango, um inventor de produtos capacitados por IA, alavancando experiência em aprendizado profundo, aprendizado de máquina, computação distribuída e métodos computacionais. Ele também forneceu cargos de liderança de pensamento como cientista-chefe de dados e diretor de startups e grandes empresas.

Este artigo mostrará como implementar um algoritmo de classificação, conhecido como regressão logística multinomial, para identificar o conjunto de dados de dígitos manuscritos. Você usará o núcleo do TensorFlow e o Keras para implementar esse algoritmo de regressão logística.

Regressão logística com o TensorFlow

Um dos exemplos mais populares em relação à classificação multiclasse é rotular as imagens de dígitos manuscritos. As classes, ou rótulos, neste exemplo são {0,1,2,3,4,5,6,7,8,9} . O conjunto de dados que você usará é popularmente conhecido como MNIST e está disponível no seguinte link: http://yann.lecun.com/exdb/mnist/ . O conjunto de dados MNIST tem 60.000 imagens para treinamento e 10.000 imagens para teste. As imagens no conjunto de dados são exibidas da seguinte maneira:

1. Primeiro, import datasetslib , uma biblioteca de https://github.com/PacktPublishing/TensorFlow-Machine-Learning-Projects :

 DSLIB_HOME = '../datasetslib' 
 import sys 
 if not DSLIB_HOME in sys.path: 
 sys.path.append(DSLIB_HOME) 
 %reload_ext autoreload 
 %autoreload 2 
 import datasetslib as dslib 
 from datasetslib.utils import imutil 
 from datasetslib.utils import nputil 
 from datasetslib.mnist import MNIST 

2. Defina o caminho para a pasta datasets em seu diretório inicial, que é onde você deseja que todos os datasets de datasets sejam armazenados:

 import os 
 datasets_root = os.path.join(os.path.expanduser('~'),'datasets') 

3. Obtenha os dados MNIST usando seu datasetslib e imprima as formas para garantir que os dados sejam carregados corretamente:

 mnist=MNIST() 
 x_train,y_train,x_test,y_test=mnist.load_data() 
 mnist.y_onehot = True 
 mnist.x_layout = imutil.LAYOUT_NP 
 x_test = mnist.load_images(x_test) 
 y_test = nputil.onehot(y_test) 
 print('Loaded x and y') 
 print('Train: x:{}, y:{}'.format(len(x_train),y_train.shape)) 
 print('Test: x:{}, y:{}'.format(x_test.shape,y_test.shape)) 

4. Definir os hiperparâmetros para treinar o modelo:

 learning_rate = 0.001 
 n_epochs = 5 
 mnist.batch_size = 100 

5. Defina os espaços reservados e parâmetros para o seu modelo simples:

 # define input images 
 x = tf.placeholder(dtype=tf.float32, shape=[None, mnist.n_features]) 
 # define output labels 
 y = tf.placeholder(dtype=tf.float32, shape=[None, mnist.n_classes]) 
 # model parameters 
 w = tf.Variable(tf.zeros([mnist.n_features, mnist.n_classes])) 
 b = tf.Variable(tf.zeros([mnist.n_classes])) 

6. Definir o modelo com logits e y_hat :

 logits = tf.add(tf.matmul(x, w), b) 
 y_hat = tf.nn.softmax(logits) 

7. Defina a função de loss :

 epsilon = tf.keras.backend.epsilon() 
 y_hat_clipped = tf.clip_by_value(y_hat, epsilon, 1 - epsilon) 
 y_hat_log = tf.log(y_hat_clipped) 
 cross_entropy = -tf.reduce_sum(y * y_hat_log, axis=1) 
 loss_f = tf.reduce_mean(cross_entropy) 

8. Defina a função optimizer :

 optimizer = tf.train.GradientDescentOptimizer 
 optimizer_f = optimizer(learning_rate=learning_rate).minimize(loss_f) 

9. Defina a função para verificar a precisão do modelo treinado:

 predictions_check = tf.equal(tf.argmax(y_hat, 1), tf.argmax(y, 1)) 
 accuracy_f = tf.reduce_mean(tf.cast(predictions_check, tf.float32)) 

10. Execute o loop de training para cada época em uma sessão do TensorFlow:

 n_batches = int(60000/mnist.batch_size) 
 with tf.Session() as tfs: 
 tf.global_variables_initializer().run() 
 for epoch in range(n_epochs): 
 mnist.reset_index() 
 for batch in range(n_batches): 
 x_batch, y_batch = mnist.next_batch() 
 feed_dict={x: x_batch, y: y_batch} 
 batch_loss,_ = tfs.run([loss_f, optimizer_f],feed_dict=feed_dict ) 
 #print('Batch loss:{}'.format(batch_loss)) 

11. Execute a função de avaliação para cada época com os dados de teste na mesma sessão do TensorFlow que foi criada anteriormente:

 feed_dict = {x: x_test, y: y_test} 
 accuracy_score = tfs.run(accuracy_f, feed_dict=feed_dict) 
 print('epoch {0:04d} accuracy={1:.8f}' 
 .format(epoch, accuracy_score)) 

Você obterá a seguinte saída:

 epoch 0000 accuracy=0.73280001 epoch 0001 accuracy=0.72869998 epoch 0002 accuracy=0.74550003 epoch 0003 accuracy=0.75260001 epoch 0004 accuracy=0.74299997 

Ai está. Você acabou de treinar seu primeiro modelo de regressão logística usando o TensorFlow para classificar imagens digitadas à mão e obteve 74.3% de precisão. Agora, veja como escrever o mesmo modelo em Keras torna esse processo ainda mais fácil.

Regressão logística com Keras

O Keras é uma biblioteca de alto nível que está disponível como parte do TensorFlow. Nesta seção, você reconstruirá o mesmo modelo construído anteriormente com o núcleo do TensorFlow com o Keras:

1. Keras leva os dados em um formato diferente e, portanto, você deve primeiro reformatar os dados usando datasetslib :

 x_train_im = mnist.load_images(x_train) 
 x_train_im, x_test_im = x_train_im / 255.0, x_test / 255.0 

No código anterior, você está carregando as imagens de treinamento na memória antes de dimensionar as imagens de treinamento e de teste, dividindo-as por 255 .

2. Então, você constrói o modelo:

 model = tf.keras.models.Sequential([ 
 tf.keras.layers.Flatten(), 
 tf.keras.layers.Dense(10, activation=tf.nn.softmax) 
 ]) 

3. Compile o modelo com o otimizador sgd . Defina a entropia categórica como a função de loss e a precisão como uma métrica para testar o modelo:

 model.compile(optimizer='sgd', 
 loss='sparse_categorical_crossentropy', 
 metrics=['accuracy']) 

4. Treine o modelo para 5 épocas com o conjunto de treinamento de imagens e rótulos:

 model.fit(x_train_im, y_train, epochs=5) 
 Epoch 1/5 
 60000/60000 [==============================] - 3s 45us/step - loss: 0.7874 - acc: 0.8095 
 Epoch 2/5 
 60000/60000 [==============================] - 3s 42us/step - loss: 0.4585 - acc: 0.8792 
 Epoch 3/5 
 60000/60000 [==============================] - 2s 42us/step - loss: 0.4049 - acc: 0.8909 
 Epoch 4/5 
 60000/60000 [==============================] - 3s 42us/step - loss: 0.3780 - acc: 0.8965 
 Epoch 5/5 
 60000/60000 [==============================] - 3s 42us/step - loss: 0.3610 - acc: 0.9012 
 10000/10000 [==============================] - 0s 24us/step 

5. Avalie o modelo com os dados de teste:

 model.evaluate(x_test_im, nputil.argmax(y_test)) 

Você obterá as seguintes pontuações de avaliação como saída:

 [0.33530342621803283, 0.9097] 

Uau! Usando Keras, você pode obter maior precisão. Aqui, você alcançou aproximadamente 90% de precisão. Isso ocorre porque Keras define internamente muitos valores ideais para que você possa rapidamente começar a criar modelos.

Se você achou este artigo interessante, pode explorar os projetos de aprendizado de máquina TensorFlow para implementar as ofertas do TensorFlow, como TensorBoard, TensorFlow.js, TensorFlow Probability e TensorFlow Lite, para criar projetos de automação inteligentes. Com a ajuda do TensorFlow Machine Learning Projects , você não apenas aprenderá a construir projetos avançados usando diferentes conjuntos de dados, mas também poderá enfrentar desafios comuns usando uma variedade de bibliotecas do ecossistema TensorFlow.