<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Lívia Alves on Medium]]></title>
        <description><![CDATA[Stories by Lívia Alves on Medium]]></description>
        <link>https://medium.com/@alvzslivia?source=rss-493a7252640d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*EUx46Fhi_PFzMSTo6NgUow.png</url>
            <title>Stories by Lívia Alves on Medium</title>
            <link>https://medium.com/@alvzslivia?source=rss-493a7252640d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 04:55:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@alvzslivia/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Backtracking Algorithm in Python to solve Sudoku Game]]></title>
            <link>https://medium.com/@alvzslivia/backtracking-algorithm-in-python-to-solve-sudoku-game-966ac9e62360?source=rss-493a7252640d------2</link>
            <guid isPermaLink="false">https://medium.com/p/966ac9e62360</guid>
            <category><![CDATA[sudoku]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[games]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Lívia Alves]]></dc:creator>
            <pubDate>Sat, 09 Aug 2025 15:50:42 GMT</pubDate>
            <atom:updated>2025-08-09T15:50:42.288Z</atom:updated>
            <content:encoded><![CDATA[<p>Games are really a great way to study and understand algorithms, because normally they have an clear objective (final state), clear rules and the player needs to do choices that usually influence the rest of the game and the follower options. As humans, we can think like &quot;if I do this move, my opponent can do that move that allow me to win the game&quot; or &quot;if I do this, my options for the next move are reduced&quot; and you know, many else, depending of the game. We can even try to evaluate some scenarios based on our move, as well as the scenarios that follow, but it is almost impossible to think of all of them. In tic-tac-toe, for example, we have about <strong>362,880</strong> possible move sequences if we consider all permutations. The possibilities for chess are even bigger — many algorithms struggle to capture them. There are about <strong>10⁴³</strong> possible legal positions.</p><p>Here is a case of study of <strong>Backtracking algorithms</strong> to test a solution for Sudoku games. The rules of this game are really clear: every box must be filled with a number. Every row, column and 3x3 block must be filled with nine unique numbers to 1 to 10. Some of the blocks already come filled, and the challenge it’s to fill the rest following the rules.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/445/0*WRj6Rf8oMtdqUq4Y.jpg" /></figure><p>Also important to know that well designed sudoku games always have a unique solution (but sometimes you can find games with more than one). I’m not the best Sudoku player, but I really enjoy them since always and it was pretty fun to use coding to solve it.</p><h3>Exploring the Dataset</h3><p>To apply all of this in Python, I found a really<a href="https://www.kaggle.com/datasets/bryanpark/sudoku"> nice database on Kaggle with 1 million sudoku games and their solutions</a>. I used the kaggle python library to get the dataset, but you can also download the raw file. As I’m not going to use all the games, I read just the first 10 rows using pandas.</p><pre>import kagglehub<br>import pandas as pd <br><br>path = kagglehub.dataset_download(&quot;bryanpark/sudoku&quot;)<br>path = f&quot;{path}/sudoku.csv&quot;<br>sudoku = pd.read_csv(path, nrows=10)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7OeZlezcrNu-HLL0MxeTCw.png" /></figure><p>To deal with this data on a easily way and be able to identify the rows and columns, we can create a function that get this big string and divide it on lists of 9 numbers each, representing the rows. A game will have 9 rows in total.</p><pre>def str_to_grid(sudoku_str):<br>    return [[int(sudoku_str[i * 9 + j]) for j in range(9)] for i in range(9)]<br><br>print(str_to_grid(sudoku.iloc[0][&#39;quizzes&#39;]))</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xlX2fNTM3flJ7l1Zzui04A.png" /></figure><p>Now it’s way more simple to work and access the rows, columns and 3x3 blocks, see:</p><pre>game1[2] # get line 3<br>[game1[i][2] for i in range(9)] # get column 3</pre><p>To get the 3x3 block, we will need a specific function, that will get the full board and the coordinates of the box we want to see (example: row 4, column 4). And it will return it as a list, like the columns and rows above.</p><pre>def get_box_from_cell(board, row, col):<br>    start_row = 3 * (row // 3)<br>    start_col = 3 * (col // 3)<br><br>    box = [<br>        board[i][j]<br>        for i in range(start_row, start_row + 3)<br>        for j in range(start_col, start_col + 3)<br>    ]<br>    return box<br><br>game1 = str_to_grid(sudoku.iloc[0][&#39;quizzes&#39;]) <br>print(&#39;Row 3: &#39;) <br>print(game1[2])<br>print(&#39;\nColumn 3: &#39;)<br>print([game1[i][2] for i in range(9)])<br>print(&#39;\nBlock for cell in row 4, column 4: &#39;)<br>print(get_box_from_cell(game1, 3, 3))</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/938/1*Xtsk70VSrQXYeIBxO82s8Q.png" /></figure><h3>Backtracking Algorithm</h3><p><a href="https://www.geeksforgeeks.org/backtracking-algorithms/">Backtracking</a> is an algorithm used to find solutions <strong>by exploring all possible options and “backtracking” when a choice leads to a not expecting ending.</strong> It’s a type of DFS (depth-first search).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lWvMTZfhHDgzM6uj.gif" /><figcaption>DFS process to solve a maze</figcaption></figure><p>For the Sudoku case, this are the steps that our algorithm need to do to get into a real and acceptable solution:</p><p><strong>A) Find an empty box.</strong> In our dataset, the empty box are represented by 0, so we will need a function to walk thought the board, and the lines inside it, and verify each box to find the next &quot;0&quot;. This will be the box we are going to try to fill.</p><p>This function will return the coordinate of the next box that is equal to 0, a list representing [row, column]. If all boxes has a valid number, it means we filled all the board, so we return None .</p><pre>def search_next_move(board):<br>    for row in range(len(board)): # for each row<br>        for num in range(len(board[row])): # for block in row<br>            if board[row][num] == 0: <br>                return [row, num] # return position on board<br>    return None # win  </pre><p><strong>B) Find a valid solution to that box.</strong> We know that we only can fill the boxes with numbers from 1 to 9. So we can make a &quot;for&quot; statement to try to fill that box with those numbers. But before doing this, <strong>we need to verify if the number that we are trying to write there is valid</strong>, and we can do this by looking at the line, column and 3x3 of that box and being sure that this number doesn’t already exist on any of them. If exists, we will try the next number and so on.</p><p>The function below do the validation of a list. So it will receive a list and the number we are trying to input. On a count, if that number receive a number different of 0, it means that number is already in the list, which means we can’t write it there.</p><pre>def validate_row(row, num_to_insert):<br>    if row.count(num_to_insert) &gt; 0: # verify if number is already on &quot;row&quot; (it can be row, column or mini board)<br>        return False<br>    else: <br>        return True<br></pre><p>And this other function receive the board, the number we are trying to input and in which box we are trying to do it. So it can use the validate_row function to validate the rows, the columns and the 3x3 blocks (because they can all be accessed as lists).</p><pre>def validate_move(board, move, num_to_insert):<br>    row = move[0]<br>    column = move[1]<br>    <br>    column_nums = [board[i][column] for i in range(9)]<br>    row_nums = board[row]<br>    mini_board = get_box_from_cell(board, row, column)<br>    <br>    # validate row, column and mini board (verify if number dont exist)<br>    if not validate_row(column_nums, num_to_insert) or not validate_row(row_nums, num_to_insert) or not validate_row(mini_board, num_to_insert):<br>        return False <br>    else:<br>        return True</pre><p>Note that the move insert is a list, just as the function search_next_move returns.</p><p>Now let’s put this two steps together and make a loop to try to insert a number from 1 to 9 into the box.</p><pre>def solve(board):<br>    # search for next empty cell, if there isnt, the game is complete<br>    move = search_next_move(board) <br>    if move is None: <br>        return board # end of game<br><br>    row, col = move<br><br>    # try to fill empty cell with some number between 1 and 9<br>    for num in range(1, 10):<br>        if validate_move(board, (row, col), num): <br>            board[row][col] = num # fill cell<br>            ...</pre><p>Ok, but there’s a problem: as I said before, Sudoku board usually has one solution, but at the start, some boxes can have several valid numbers. So, imagine: our algorithm might pick a valid number like “2” for a box, but that “2” actually belongs in a different box in the same row. T<strong>hat’s why we use backtracking. The function calls itself recursively, and if it reaches a dead end, it erases the last number and tries a different one</strong> — just like the gif of the maze above: when hitting a wall, the algorithm comes back to the last move and try a different path (in our case, a different number).</p><p>That’s how it works:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*4jxdS1X98O0K9H-8.gif" /></figure><p><strong>C) Apply recursive function to find the solution.</strong> So each time we find a valid solution for a block, we follow to the next. If in some point there’s no solution left, we go back to last step, and try another number. I also put a variable to count the numbers of steps, to see how hard was to find the solution for each puzzle.</p><pre>def solve(board):<br>    global step_count<br>    # search for next empty cell, if there isnt, the game is complete<br>    move = search_next_move(board) <br>    if move is None: <br>        return board # end of game<br><br>    row, col = move<br><br>    # try to fill empty cell with some number between 1 and 9<br>    for num in range(1, 10):<br>        if validate_move(board, (row, col), num): <br>            step_count += 1<br>            board[row][col] = num # fill cell<br>            if solve(board): # call the function recursivly to try to resolve the rest of the board<br>                return board # end of game<br>            board[row][col] = 0 # if fails, try another number <br><br>    # the game cant be complete<br>    return False</pre><p><strong>D) Apply process to the games. </strong>As I limited my dataset to 10 games, this is the number of results we will get, but you can try with more. (Just be careful! The dataset contains 1 million games and run through all of them can break your code).</p><pre>for i, row in sudoku.iterrows():<br>    step_count = 0<br>    print(f&quot;Solving Game {i+1}:&quot;)<br>    game_grid = str_to_grid(sudoku.iloc[i][&#39;quizzes&#39;])<br>    solution_grid = str_to_grid(sudoku.iloc[i][&#39;solutions&#39;])<br>    <br>    solution_found = solve(game_grid)<br>    <br>    if not solution_found:<br>        print(&quot;No solution found :( \n&quot;)<br>    else:<br>        print(f&quot;Solution found in {step_count} iterations!&quot;)<br>        print(f&quot;Solution equal to the given on dataset? {solution_found == solution_grid}\n&quot;)</pre><pre>Solving Game 1:<br>Solution found in 181 iterations!<br>Solution equal to the given on dataset? True<br><br>Solving Game 2:<br>Solution found in 95 iterations!<br>Solution equal to the given on dataset? True<br><br>Solving Game 3:<br>Solution found in 99 iterations!<br>Solution equal to the given on dataset? True<br><br>Solving Game 4:<br>Solution found in 274 iterations!<br>Solution equal to the given on dataset? True<br><br>Solving Game 5:<br>Solution found in 93 iterations!<br>Solution equal to the given on dataset? True<br><br>Solving Game 6:<br>Solution found in 115 iterations!<br>Solution equal to the given on dataset? True<br><br>Solving Game 7:<br>Solution found in 71 iterations!<br>Solution equal to the given on dataset? True<br><br>Solving Game 8:<br>Solution found in 184 iterations!<br>Solution equal to the given on dataset? True<br><br>Solving Game 9:<br>Solution found in 222 iterations!<br>Solution equal to the given on dataset? True<br><br>Solving Game 10:<br>Solution found in 49 iterations!<br>Solution equal to the given on dataset? True</pre><p>Our backtracking algorithm successfully solved all the Sudoku puzzles in the sample, and the solutions matched the dataset answers. This confirms that the method is reliable and accurate for solving these kinds of problems. If you’re interested in exploring the implementation or trying it yourself, you can <a href="https://github.com/liviaalvzs/sudoku-backtracking">access the full code here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=966ac9e62360" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desenvolvimento e Diagnóstico de Problemas em Modelos de Classificação com Redes Neurais]]></title>
            <link>https://medium.com/@alvzslivia/desenvolvimento-e-diagn%C3%B3stico-de-problemas-em-modelos-de-classifica%C3%A7%C3%A3o-com-redes-neurais-01dc46628a48?source=rss-493a7252640d------2</link>
            <guid isPermaLink="false">https://medium.com/p/01dc46628a48</guid>
            <category><![CDATA[neural-networks]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[aprendizado-de-maquina]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[redes-neurais]]></category>
            <dc:creator><![CDATA[Lívia Alves]]></dc:creator>
            <pubDate>Sat, 13 Jul 2024 19:08:00 GMT</pubDate>
            <atom:updated>2024-07-23T16:27:25.428Z</atom:updated>
            <content:encoded><![CDATA[<p>O objetivo aqui é explorar o desenvolvimento e diagnóstico de problemas em modelos de classificação utilizando Redes Neurais. Para demonstrar esse processo, será utilizado o conjunto de dados <a href="https://www.tensorflow.org/datasets/catalog/fashion_mnist?hl=pt-br">Fashion MNIST</a>, um benchmark bem popular em tarefas de classificação de imagens.</p><p><strong>Abaixo, as bibliotecas que serão usadas:</strong></p><pre>import tensorflow as tf<br>from tensorflow import keras<br>from tensorflow.keras import layers<br><br>import pandas as pd<br>import numpy as np<br><br>import matplotlib as mpl<br>import matplotlib.pyplot as plt<br></pre><p><strong>Definição do estilo dos plots:</strong></p><pre>import catppuccin<br>mpl.style.use(catppuccin.PALETTE.mocha.identifier)</pre><h3>Introdução ao Dataset Fashion MNIST</h3><p>O <a href="https://www.tensorflow.org/datasets/catalog/fashion_mnist?hl=pt-br">Fashion MNIST</a> é um dataset composto por 70.000 imagens de itens de vestuário em 10 categorias diferentes, onde cada imagem tem uma resolução de 28x28 pixels.</p><p>No trecho de código abaixo, importamos o dataset usando Keras:</p><pre># importando o dataset<br>fashion_mnist = keras.datasets.fashion_mnist<br><br># carregando os dados de treinamento e teste<br>(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()</pre><p>Cada categoria de vestuário no dataset possui uma label associada (um número de 0 a 9). Para facilitar a análise e interpretação dos resultados, podemos criar um dicionário que relacione essas labels às descrições das categorias.</p><pre># relacao de label/categoria<br>fashion_mnist_labels = {<br>    0: &#39;T-shirt/Top&#39;,<br>    1: &#39;Trouser&#39;,<br>    2: &#39;Pullover&#39;,<br>    3: &#39;Dress&#39;,<br>    4: &#39;Coat&#39;,<br>    5: &#39;Sandal&#39;,<br>    6: &#39;Shirt&#39;,<br>    7: &#39;Sneaker&#39;,<br>    8: &#39;Bag&#39;,<br>    9: &#39;Ankle Boot&#39;<br>}</pre><p><em>No entanto, durante o treinamento do nosso modelo, utilizaremos os rótulos numéricos, por serem mais adequados para o processamento. </em><strong><em>Este método é conhecido como Label Encoding.</em></strong></p><p>Para conhecer o dataset, podemos visualizar uma imagem aleatória (item 100 da lista de treino, por exemplo) usando Matplotlib:</p><pre># visualizando imagem aleatoria (item 100 da lista de treino)<br>plt.imshow(train_images[100], cmap=plt.cm.binary)<br># exibe a label e a sua descricao com base no dict &#39;fashion_mnist_labels&#39;<br>plt.title(f&#39;Label {train_labels[100]} ({fashion_mnist_labels[train_labels[100]]})&#39;)<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/416/1*jPAQ5WaZYSwqUyJODyQoRg.png" /><figcaption>Imagem 100 do dataset de treino</figcaption></figure><p>Essa é a carinha de cada um dos itens do nosso dataset. Podemos também visualizar mais alguns de uma única vez para explorarmos mais categorias:</p><pre># visualizando as 25 primeiras imagens do dataset de treino<br>plt.figure(figsize=(10, 10))<br>for i in range(25):<br>    # definindo posicao do subplot<br>    plt.subplot(5, 5, i + 1)<br>    # zerando os &#39;ticks&#39; para nao atrapalharem a visualizacao<br>    plt.xticks([])<br>    plt.yticks([])<br>    plt.imshow(train_images[i], cmap=plt.cm.binary)<br>    # mostrando as labels e descricao de cada img<br>    plt.xlabel(f&#39;Label {train_labels[i]} ({fashion_mnist_labels[train_labels[i]]})&#39;)<br><br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*8z_DYwkXWF5iWC3I7qYypQ.png" /><figcaption>As primeiras 25 imagens do dataset de treino</figcaption></figure><p>Para entender melhor o treinamento do nosso modelo é importante analisar a distribuição das categorias no nosso dataset. <strong>Verificar a quantidade de imagens de cada categoria nos permite identificar possíveis desbalanceamentos nos dados.</strong></p><p>Por exemplo, se imagens de vestidos (label 3, “Dress”) aparecem com mais frequência do que imagens de bolsas (label 8, “Bag”), o modelo pode acabar aprendendo a classificar melhor a categoria mais frequente (nesse exemplo, os vestidos). Como resultado, as previsões de imagens de bolsas podem apresentar um desempenho inferior, pois o modelo viu menos imagens parecidas no treinamento.</p><p>Podemos criar um gráfico para analisarmos essa distribuição:</p><pre># contagem das ocorrencias de cada rotulo nos conjuntos de treino e teste<br>train_label_counts = np.bincount(train_labels)<br>test_label_counts = np.bincount(test_labels)<br><br># criando o grafico<br>labels = list(fashion_mnist_labels.values())<br>x = np.arange(len(labels))<br><br>fig, ax = plt.subplots(figsize=(12, 6))<br><br>bar_width = 0.35<br>opacity = 0.45<br><br>bar_train = ax.bar(x - bar_width/2, train_label_counts, bar_width, <br>                   label=&#39;Train Set&#39;, alpha=opacity, edgecolor=&#39;white&#39;)<br>bar_test = ax.bar(x + bar_width/2, test_label_counts, bar_width, <br>                  label=&#39;Test Set&#39;, alpha=opacity, edgecolor=&#39;white&#39;)<br><br>ax.set_xlabel(&#39;Categories&#39;)<br>ax.set_ylabel(&#39;Number of Occurrences&#39;)<br>ax.set_title(&#39;Count of Each Label in the Dataset&#39;)<br>ax.set_xticks(x)<br>ax.set_xticklabels(labels, rotation=40)<br>ax.legend()<br><br>plt.tight_layout()<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bxV5On50fSD30t5k8G8r6Q.png" /><figcaption>Distribuição das categorias no Dataset</figcaption></figure><p>Podemos observar que os dados estão bem balanceados, tanto no conjunto de treino quanto no conjunto de teste. Isso garante que não vamos enfrentar problemas relacionados a uma distribuição desigual das categorias durante o treinamento.</p><h3>Normalizando os Dados</h3><p>Para melhorar o nosso treinamento e, consequentemente, a performance do modelo, normalizaremos os nossos dados para o intervalo [0, 1]. Essa prática é comum em modelos de ML, e existem diversas técnicas para isso, como <strong>Min-Max Scaling</strong>, <strong>Z-Score Scaling</strong> e etc.</p><p>Nesse caso, os dados que temos para trabalhar são os valores dos pixels de cada imagem. Utilizamos uma divisão simples por 255 para assegurar que todos os pixels estejam no intervalo desejado, facilitando a aprendizagem do modelo. <strong>Por que 255? </strong><em>Originalmente, os pixels possuem valores entre 0 e 255, onde 0 representa preto e 255 representa branco. Dividindo cada valor por 255, escalamos os pixels para um intervalo entre 0 e 1.</em></p><pre># normaliza os valores de pixel para o intervalo [0, 1]<br>norm_train_images = train_images / 255.0<br>norm_test_images = test_images / 255.0</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iaT3d5ZH1tRWLHEIWXyhLg.png" /><figcaption>Um mesmo dado antes e depois da sua normalização</figcaption></figure><h3>Criando o Modelo</h3><p>Nosso modelo de Redes Neurais conta, primeiramente, com uma camada Flatten . Essa camada vai transformar nossos dados, que são matrizes 2D 28x28 em um vetor unidimensional. Isso é necessário para que as camadas seguintes possam trabalhar com eles da forma correta.</p><p>Em seguida temos uma camada Dense com 128 neurônios e a função de ativação ReLU. Esta camada vai fazer a rede aprender padrões importantes nas imagens, sendo assim, capaz de distinguir as diferentes categorias de vestuário.</p><p>A última camada do nosso modelo é outra camada Dense, desta vez com 10 neurônios (correspondendo às 10 categorias de roupas no dataset). Essa camada fornece as probabilidades de cada imagem pertencer a uma das categorias.</p><pre># definir a semente para reprodutibilidade<br>seed = 42<br>tf.random.set_seed(seed)<br>np.random.seed(seed)<br><br># modelo<br>model = keras.Sequential([<br>    layers.Flatten(input_shape=(28, 28)),<br>    layers.Dense(128, activation=&#39;relu&#39;),<br>    layers.Dense(10)<br>])</pre><p>Para treinar a rede, utilizaremos o otimizador Adame vamos compilar o modelo com a função de perda SparseCategoricalCrossentropy, bem adequada para problemas de classificação onde as classes são representadas por inteiros como as nossas labels. Também incluímos a métrica de acurácia para podermos avaliar o desempenho do modelo durante o treinamento.</p><pre># compliando o modelo<br>model.compile(optimizer=&#39;adam&#39;,<br>              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),<br>              metrics=[&#39;accuracy&#39;])</pre><h3>Treinando o Modelo</h3><p>Para treinar o modelo, vamos usar o método fit , passando nossos dados de treino normalizados e suas respectivas labels. Esse método vai ajustar os pesos do modelo com base nos dados de entrada e nas saídas, por um numero x de iterações ( epochs = 20), procurando minimizar a função de perda definida durante a compilação do modelo, no nosso caso, a SparseCategoricalCrossentropy.</p><pre>model.fit(norm_train_images, train_labels, epochs=20)</pre><p><em>Treinar por mais épocas pode permitir que o modelo aprenda melhor os padrões nos dados, mas também pode levar ao overfitting.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MqzAA2gZa6wSORccPxwRlg.png" /><figcaption>Treinamento do Modelo</figcaption></figure><h3>Realizando Predições</h3><p>Agora vamos utilizar o modelo treinado acima para obter predições.</p><p>Vamos passar as imagens do nosso conjunto de testes, que o modelo ainda não viu, e esperar que ele, com base nos dados de treinamento, consiga nos dizer a qual categoria aquela imagem pertence, ou seja, se é uma bolsa, um vestido, uma bota, etc.</p><p>Para tornar essa etapa mais intuitiva, adicionamos uma camada Softmax ao modelo original, criando um novo modelo que converte os logits (valores não normalizados) em probabilidades. Essa conversão nos permite entender melhor a confiança do modelo em cada previsão, ou seja, se ele tem certeza que uma imagem representa uma camiseta ou se ele ficou em duvida entre ser uma camiseta e um vestido, por exemplo.</p><pre># realizando predicoes<br>probability_model = tf.keras.Sequential([model, tf.keras.layers.Softmax()])<br>predictions = probability_model.predict(test_images)</pre><h3>Avaliando as Predições do Modelo</h3><p>Agora a variável predictions possui os valores que o nosso modelo tentou adivinhar para o conjunto de testes. Podemos visualizar a primeira predição da seguinte forma:</p><pre># visualizando a predicao para a primeira imagem do conjunto de testes<br>print(&#39;First prediction for the test set... 🧙‍♀️🔮&#39;)<br>print(f&#39;Predicted label: {np.argmax(predictions[0])}, True label: {test_labels[0]}&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6pRv4H4Xe95UIoY6ObxUjA.png" /></figure><p>O nosso modelo acertou ao prever a categoria da primeira imagem do nosso conjunto de testes! Legal! Mas como será que ele se saiu com as outras imagens? Será que ele manteve um bom desempenho ou cometeu muitos erros? Durante o treinamento, o modelo atingiu uma acurácia de 0,93. Vamos explorar mais os erros cometidos pelo modelo para entender melhor seu desempenho.</p><h4>É aí que entra uma parte super importante e o verdadeiro foco deste artigo: <strong>o Diagnóstico de Problemas.</strong> <strong>Como melhorar um modelo sem saber onde ele está falhando?!</strong></h4><p>Vamos criar um dataframe com todas as nossas predições e o valor verdadeiro das suas labels, para visualizarmos graficamente onde o modelo está cometendo erros:</p><pre># lista com as predicoes e as labels corretas<br>predicted_labels = np.argmax(predictions, axis=1)<br>correct_labels = test_labels<br><br># dataframe com as previsoes e as labels corretas<br>df = pd.DataFrame({<br>    &#39;predicted label&#39;: predicted_labels,<br>    &#39;true label&#39;: correct_labels<br>})<br><br># coluna boleana indicando se errou<br>df[&#39;error&#39;] = df[&#39;predicted label&#39;] != df[&#39;true label&#39;]</pre><p>Podemos agora calcular quantos erros o nosso modelo cometeu no total, tanto em numero absoluto quanto em porcentagem, para entendermos o que uma acurácia de 0,93 significou nesse nosso dataset.</p><pre># quantidade de erros (absoluto)<br>num_errors = df[&#39;error&#39;].sum()<br># quanridade de erros (%)<br>total_predictions = len(df)<br>error_percentage = (num_errors / total_predictions) * 100<br><br>print(f&#39;Number of errors 😐: {num_errors} ({error_percentage:.2f}%)&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0DS9puLS1QWXJyFhigsGmQ.png" /><figcaption>Exibição do dataframe e quantidade de erros</figcaption></figure><p>Aqui podemos ver que a taxa de erros do nosso modelo foi de 13,94%. Mesmo que não seja uma taxa suuper alta, é importante entender esses erros. <strong>Será que existe alguma categoria específica onde ele teve mais dificuldade em realizar as predições e, consequentemente, errou mais?</strong></p><p>Nossos dados de treinamento estavam balanceados (plotamos até um gráfico para conferir isso anteriormente), então podemos descartar a possibilidade de que o modelo tenha visto algumas categorias menos vezes do que outras. Mesmo assim, ainda existem outros cenários possíveis que podem ter contribuído pra esses erros. <strong>Vamos analisar mais os resultados e identificar quais categorias foram mais problemáticas!</strong></p><p>Usando o dataframe que criamos, podemos agrupar os erros por categoria e plotar um gráfico indicando-os.</p><pre># contagem do numero de erros por categoria<br>error_counts = df[df[&#39;error&#39;]].groupby(&#39;true label&#39;).size()<br><br># mapeamento de indices de categorias para nomes das categorias<br>category_names = list(fashion_mnist_labels.values())<br>error_counts.index = error_counts.index.map(lambda x: fashion_mnist_labels[x])<br><br># grafico das categorias que mais erraram<br>plt.figure(figsize=(12, 8))<br>error_counts.sort_values().plot(kind=&#39;barh&#39;, alpha=0.45, edgecolor=&#39;white&#39;)<br>plt.xlabel(&#39;Number of Errors&#39;)<br>plt.ylabel(&#39;Category&#39;)<br>plt.title(&#39;Number of Errors by Category&#39;)<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*--0rIaMh7wRs0pEZkwtnOA.png" /><figcaption>Erros agrupados por categoria</figcaption></figure><p>Analisando o gráfico acima, podemos ver que tivemos erros em todas as categorias, mas “Shirt” e “Pullover” lideram em quantidade. Realizando uma análise simples e intuitiva, sabemos que camisas e suéteres podem se parecer bastante! Isso pode indicar onde o nosso modelo está se confundindo. Além disso, as categorias “Dress”, “T-shirt/Top” e &quot;Coat&quot; aparecem em terceiro, quarto e quinto, o que faz sentido, pois pensando bem, elas também podem ser confundidas com camisas e suéteres.</p><p>Vamos criar algum embasamento para essa teoria e ver se nossos dados provam se isso é real.</p><pre># categorias que queremos visualizar (as que mais erraram, indicadas no grafico acima)<br>categories_to_plot = [&#39;Shirt&#39;, &#39;Pullover&#39;, &#39;Dress&#39;, &#39;T-shirt/Top&#39;, &#39;Coat&#39;]<br>category_indices = {category: [] for category in categories_to_plot}<br><br># seleciona aleatoriamente 5 imagens de cada categoria mencionada<br>for category in categories_to_plot:<br>    category_label = [k for k, v in fashion_mnist_labels.items() if v == category][0]<br>    indices = np.where(train_labels == category_label)[0]<br>    selected_indices = np.random.choice(indices, 5, replace=False)<br>    category_indices[category] = selected_indices<br><br># criando grafico com as categorias<br>plt.figure(figsize=(12, 12))<br>for i, category in enumerate(categories_to_plot):<br>    for j in range(5):<br>        idx = category_indices[category][j]<br>        # definindo posição do subplot<br>        plt.subplot(5, 5, i * 5 + j + 1)<br>        # xerando os &#39;ticks&#39; para não atrapalharem a visualização<br>        plt.xticks([])<br>        plt.yticks([])<br>        plt.imshow(train_images[idx], cmap=plt.cm.binary)<br>        # mostrando as categorias<br>        if j == 0:<br>            plt.ylabel(f&#39;{category}&#39;, fontsize=14, labelpad=30)<br><br>plt.tight_layout()<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*azO76poDOVha9Z4qi0iTKQ.png" /><figcaption>Exibindo algumas categorias para estabelecer similaridade</figcaption></figure><p>Aqui, podemos ver cinco exemplos das quatro categorias com maior número de erros e, realmente, algumas imagens podem ser facilmente confundidas por serem muito parecidas com imagens de outras categorias.</p><p>Além de fornecer as previsões, nosso modelo também retorna a probabilidade associada a cada categoria, indicando o nível de confiança do modelo em sua previsão. Basicamente, o grau de incerteza do modelo, o quanto ele ficou em duvida.</p><p>Podemos pegar todos os erros das imagens que representavam “Shirt”, ver o que o modelo achou que eram (ou seja, pegar a label com maior probabilidade nas predições) e visualizar isso graficamente.</p><pre># filtrar os dados para a categoria &#39;Shirt&#39; que foram classificadas incorretamente<br>shirt_label = 6<br>shirt_errors = df[(df[&#39;true label&#39;] == shirt_label) &amp; (df[&#39;error&#39;])]<br><br># add probabilidades maximas as previsoes erradas<br>shirt_errors[&#39;max_probability&#39;] = [np.max(predictions[i]) for i in shirt_errors.index]<br>shirt_errors[&#39;predicted_category&#39;] = [fashion_mnist_labels[pred] for pred in shirt_errors[&#39;predicted label&#39;]]</pre><p>A variável shirt_errors possui agora um dataframe associado, com os erros que o modelo teve ao prever imagens da categoria “Shirt” (a que ele mais errou). Além disso, adicionamos a coluna max_probability e predicted_category , para ver o “palpite” do nosso modelo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tIMpMFZi47RS5YMy4MztRQ.png" /><figcaption>Dataframe exibindo os erros com a probabilidade (nível de confiança)</figcaption></figure><p>A primeira linha, por exemplo, previu com 100% de certeza (max_probability = 1) que a imagem se tratava de uma “T-shirt/Top”.</p><p>Vamos ver os valores que temos na coluna de max_probability ?</p><pre># visualizando todos os valores da coluna &#39;max_probability&#39;<br>max_probability_values = shirt_errors[&#39;max_probability&#39;].unique()<br>print(&#39;Column: max_probability (shirt errors) 👕&#39;)<br>print(f&#39;Max Value: {max_probability_values.max()}&#39;)<br>print(f&#39;Min Value: {max_probability_values.min()}&#39;)<br>print(f&#39;Mean: {max_probability_values.mean()}&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4t73pC-HEYxj6gUcJhnibA.png" /></figure><p>Como vimos anteriormente, nosso modelo teve algumas predições com max_probability = 1, o que significa 100% de certeza. O menor valor dessa coluna foi aproximadamente 0,73 (73% de certeza), o que ainda representa um nível de confiança bastante alto do nosso modelo. A média das probabilidades máximas foi de 0,95.</p><p><strong>Ok, o que isso significa? Para os erros que o modelo cometeu ao prever a categoria “Shirt”, o nível de confiança foi sempre muito alto. Em outras palavras, o modelo estava errado, mas muito confiante de que estava certo!</strong></p><p>Ainda usando o dataframe shirt_errors , vamos calcular quais categorias mais foram previstas — erroneamente — pelo modelo.</p><pre># Contar a frequência das categorias que o modelo achou que &quot;Shirt&quot; era<br>category_confusion = shirt_errors[&#39;predicted_category&#39;].value_counts()<br><br>plt.figure(figsize=(10, 6))<br>category_confusion.plot(kind=&#39;bar&#39;, alpha=0.45, edgecolor=&#39;white&#39;)<br>plt.xlabel(&#39;Predicted Categories&#39;)<br>plt.ylabel(&#39;Frequency&#39;)<br>plt.title(&#39;Images that were &quot;Shirt&quot;, but Model was Confused with...&#39;)<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/854/1*w9m49xKn03wYxydDfjGKbQ.png" /></figure><p>Com tudo isso, tiramos a conclusão que temos um certo problema com as nossas imagens, que possuem uma qualidade baixa, fazendo o modelo se confundir ao tentar prever certas categorias de vestuário que acabam sendo muito parecidas. Por curiosidade, quis saber porque o modelo confundiu algumas imagens que eram camisas com bolsas (label &quot;Bag&quot;). Foram poucas ocorrências, mas fiquei pensativa sobre isso e, quando visualizei alguns exemplos, vi que em sua maioria, eram camisas com estampas e com um modelo que ficava difícil identificar a gola e mangas. Em alguns casos, nem eu mesma identificaria elas da forma correta. Assim vemos que, mesmo que seja possível melhorar o nosso modelo, a qualidade dos dados impedirá a sua evolução.</p><h3>Conclusão</h3><p>Neste artigo, abordamos o desenvolvimento e diagnóstico de problemas em modelos de classificação utilizando Redes Neurais com o conjunto de dados Fashion MNIST.</p><p>Com este estudo, aprendemos a importância de técnicas de normalização, construção de modelos eficientes, e diagnósticos detalhados para identificar e corrigir problemas em modelos de classificação.</p><p><a href="https://github.com/liviaalvzs/classification-diagnostics-fashion-mnist">😸<strong> Projeto no GitHub</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=01dc46628a48" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Explorando o Potencial do Amazon SageMaker na Otimização de Parâmetros para um Modelo XGBoost]]></title>
            <link>https://medium.com/@alvzslivia/explorando-o-potencial-do-amazon-sagemaker-na-otimiza%C3%A7%C3%A3o-de-par%C3%A2metros-para-um-modelo-xgboost-b8ed136efee7?source=rss-493a7252640d------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8ed136efee7</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[xgboost]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[sagemaker]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <dc:creator><![CDATA[Lívia Alves]]></dc:creator>
            <pubDate>Mon, 27 May 2024 23:26:08 GMT</pubDate>
            <atom:updated>2024-07-26T17:14:42.186Z</atom:updated>
            <content:encoded><![CDATA[<p>O XGBoost é um algoritmo de Machine Learning que enquadra-se na categoria das árvores de decisão, combinando várias árvores menores para fornecer previsões mais precisas e confiáveis. Mas, <strong>como qualquer outro modelo de ML, o que vai ditar a sua eficiência são os parâmetros usados em seu treinamento.</strong></p><p>Uma das maiores dificuldades que tenho ao lidar com modelos de Machine e Deep Learning são os testes de parâmetros. Muitas vezes, devido ao tamanho e complexidade dos dados, <strong>esses testes consomem bastante tempo e demandam uma grande capacidade computacional.</strong> Capacidade essa que, muitas vezes, nem temos.</p><p>Podemos tentar usar o Grid Search ou até mesmo técnicas como Randomized Search para otimização de parâmetros, mas nem sempre esses métodos resolvem o problema completamente. Eles podem até reduzir o espaço de busca, mas ainda assim, a busca pelo conjunto ideal de parâmetros pode ser complexa.</p><p>O <strong>SageMaker</strong>, o serviço de IA da Amazon, oferece recursos poderosos para <strong>Otimização de Hiperparâmetros (HPO)</strong>, sendo beeem útil em casos em que o espaço de busca é grande ou os recursos computacionais são limitados.</p><p>Aqui vou trazer uma visão de como isso pode ser feito usando basicamente o SageMaker Studio, um ambiente integrado de desenvolvimento, um Jupyter Notebook e os Training Jobs do SageMaker.</p><h3>Antes de tudo… Como funciona a HPO que vamos estruturar?</h3><p><strong>Criaremos um script que treina o modelo usando diferentes combinações de parâmetros.</strong> O SageMaker executa automaticamente várias tentativas de treinamento, cada uma com um conjunto diferente de parâmetros. Por exemplo, se definirmos o intervalo do parâmetro1 entre 1 e 10 e do parâmetro2 entre 0.1 e 1, e um número de jobs igual a 10, ele vai rodar o script de treino 10 vezes, alternando os valores dos parâmetros 1 e 2 dentro dos intervalos definidos. <strong>Ele testa essas combinações para encontrar quais parâmetros produzem o melhor desempenho do modelo.</strong> Isso torna o processo mais eficiente, permitindo que você encontre a melhor configuração de parâmetros de forma mais rápida e organizada, além de possibilitar um entendimento melhor de como os parâmetros afetam o modelo.</p><h3>1. Domínio e Perfil de Usuario</h3><p>Um domínio é um ambiente otimizado para a execução de tarefas de ML. Um domínio pode conter um ou mais perfis de usuário, e cada perfil de usuário possui suas próprias aplicações pessoais, incluindo o SageMaker Studio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/991/1*2qLUGpjFpclstSnpzzlQrg.png" /><figcaption>Domínios no SageMaker</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/992/1*pRAVJOCdYPwyZWbUeba2gw.png" /><figcaption>Perfis de Usuario no SageMaker + Aplicações Pessoais disponíveis</figcaption></figure><h3>2. SageMaker Studio e JupyterLab</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zOaAgIzFtbONFY6bDvmSzg.png" /><figcaption>SageMaker Studio</figcaption></figure><p>O SageMaker Studio possui muitas ferramentas inclusas, como editores de código, integração com o RStudio, o Canvas (uma interface intuitiva para o desenvolvimento de modelos com abordagem totalmente low-code) e o JupyterLab, para quem prefere programar usando notebooks, que é o que usaremos.</p><p>Ao criar um novo “espaço” no JupyterLab, é possível configurar uma instancia de sua preferencia, com a ml.t3.medium como padrão, além de determinar o espaço de armazenamento desejado, sendo 5G o mínimo. Todas essas configurações influenciam diretamente no custo desses serviços.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_RMkBK9b20l82jxf85L0ug.png" /></figure><h3>3. Script de Treino</h3><p>Para começar, depois de abrir o JupyterLab, precisamos escrever um script de treino. Ele receberá conjuntos de treino, teste e validação, além dos parâmetros do modelo escolhido (nesse caso, o XGBoost). Esse script é o centro do nosso projeto, pois é por meio dele que realizaremos os Training Jobs para descobrir os melhores parâmetros. Abaixo, temos um exemplo que funcionará bem, salvo em um arquivo chamado<strong> train_script.py.</strong></p><pre>import argparse<br>import os<br>import xgboost as xgb<br>from sklearn.metrics import mean_squared_error<br><br># argumentos para o script<br>parser = argparse.ArgumentParser()<br>parser.add_argument(&#39;--max_depth&#39;, type=int, default=5)<br>parser.add_argument(&#39;--eta&#39;, type=float, default=0.1)<br>parser.add_argument(&#39;--min_child_weight&#39;, type=float, default=1)<br>parser.add_argument(&#39;--subsample&#39;, type=float, default=0.8)<br>parser.add_argument(&#39;--gamma&#39;, type=float, default=0)<br>parser.add_argument(&#39;--num_round&#39;, type=int, default=100)<br>parser.add_argument(&#39;--train&#39;, type=str, default=os.environ.get(&#39;SM_CHANNEL_TRAIN&#39;))<br>parser.add_argument(&#39;--test&#39;, type=str, default=os.environ.get(&#39;SM_CHANNEL_TEST&#39;))<br>parser.add_argument(&#39;--validation&#39;, type=str, default=os.environ.get(&#39;SM_CHANNEL_VALIDATION&#39;))<br>args = parser.parse_args()<br><br># define os parâmetros do modelo<br>param = {<br>    &#39;max_depth&#39;: args.max_depth,<br>    &#39;eta&#39;: args.eta,<br>    &#39;min_child_weight&#39;: args.min_child_weight,<br>    &#39;subsample&#39;: args.subsample,<br>    &#39;gamma&#39;: args.gamma,<br>    &#39;objective&#39;: &#39;reg:squarederror&#39;,<br>    &#39;verbosity&#39;: 0<br>}<br><br># converte os dados para o formato XGBoost<br>dtrain = xgb.DMatrix(X_train, label=y_train)<br>dtest = xgb.DMatrix(X_test, label=y_test)<br>dval = xgb.DMatrix(X_validation, label=y_validation)<br><br># treinamento do modelo<br>num_round = args.num_round<br>bst = xgb.train(param, dtrain, num_round, evals=[(dval, &#39;validation&#39;)])<br><br># realiza as previsões<br>preds = bst.predict(dtest)<br><br># avaliação do modelo<br>rmse = mean_squared_error(y_test, preds, squared=False)<br><br># salva o modelo<br>model_dir = &#39;/opt/ml/model&#39;<br>os.makedirs(model_dir, exist_ok=True)<br>bst.save_model(os.path.join(model_dir, &#39;xgboost-model&#39;))</pre><p>O modelo treinado é salvo no diretório /opt/ml/model, que é um local padrão no ambiente SageMaker para salvar modelos treinados. Os parâmetros que esse modelo irá receber são: max_deph, eta, min_child_weight, subsample, gamma e num_round . A métrica escolhida para avalia-lo será o RMSE (Erro Quadrático Médio reg:squarederror).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aYD2mn2T3QWT07ajf_1-lA.png" /><figcaption>Visão do JupyterLab com o script de treino</figcaption></figure><h3>4. Criando uma Base Fictícia e Tratando os Dados</h3><p>Em um outro arquivo (dessa vez um notebook, para facilitar as análises) vamos criar uma base falsa para simular os nossos dados.<strong> O repositório com todos os códigos se encontra no fim do artigo.</strong></p><p>O script abaixo vai definir nossa base de dados simulada, que inclui 10000 linhas com características típicas de imóveis, como área, número de quartos e banheiros, idade, distância até o centro da cidade, e por fim o preço do imóvel (calculado com base nas outras variáveis). No mundo real, a relação entre preço e características é complexa e influenciada por muitos fatores. No entanto, para fins de teste, este script simula uma relação mais direta, onde cada característica impacta o preço de forma proporcional.</p><pre>import numpy as np<br>import pandas as pd<br><br># definindo os parâmetros para a base de dados<br>np.random.seed(0)<br>n_samples = 10000<br>area = np.random.normal(150, 50, n_samples)<br>num_rooms = np.random.randint(1, 6, n_samples)<br>num_bathrooms = np.random.randint(1, 4, n_samples)<br>age = np.random.randint(1, 50, n_samples)<br>distance_to_city_center = np.random.normal(10, 5, n_samples)<br>price = 100000 + (area * 1000) + (num_rooms * 5000) - (num_bathrooms * 3000) - (age * 1000) - (distance_to_city_center * 2000)<br><br># criando o dataframe (importante deixar &quot;price&quot; - variavel predita - na primeira posicao)<br>data = pd.DataFrame({<br>    &#39;price&#39;: price,<br>    &#39;area&#39;: area,<br>    &#39;num_rooms&#39;: num_rooms,<br>    &#39;num_bathrooms&#39;: num_bathrooms,<br>    &#39;age&#39;: age,<br>    &#39;distance_to_city_center&#39;: distance_to_city_center<br>})<br><br># salvando em csv <br>data.to_csv(&#39;housing_data.csv&#39;, index=False)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/739/1*0OClK2qQeqW27s2S1leLgg.png" /><figcaption>Visão da Base de Dados criada</figcaption></figure><p>Para treinarmos um modelo, diversos tipos de tratamento são necessários nos nossos dados, mas esta base já foi criada com o intuito de ser mais simples. <strong>Se tivéssemos valores ausentes ou outliers, precisaríamos lidar com eles, assim como com colunas booleanas ou variáveis categóricas. Esse conhecimento sobre como manipular e limpar os dados de maneira correta é extremamente importante.</strong></p><p>No caso do XGBoost, as colunas não precisam de um cabeçalho. Portanto, para que o modelo identifique a variável predita, ela deve ocupar especificamente a primeira posição (essa ordem foi definida ao criar o dataframe). Outra coisa imprescindível na hora de treinar o modelo é normalizar os dados.</p><p>O script abaixo faz:</p><ul><li>a normalização dos dados usando a função StandardScaler , importada do ScikitLearn;</li><li>a divisão entre conjuntos de treino, teste e validação;</li><li>salva os arquivos em .csv sem a header e sobe esses arquivos para um bucket do S3 (que deve ser criado anteriormente);</li></ul><pre>from sklearn.preprocessing import StandardScaler<br>import boto3<br><br># configuração do bucket S3<br>bucket = &#39;hpo-data&#39;<br>s3 = boto3.client(&#39;s3&#39;)<br><br># normaliza os dados<br>scaler = StandardScaler()<br>normalized_data = scaler.fit_transform(data)<br><br># converte de volta para DataFrame<br>normalized_data = pd.DataFrame(normalized_data, columns=data.columns)<br><br># determina o número de linhas para cada conjunto (treino, teste e validacao)<br>train_size = int(0.7 * len(normalized_data))<br>test_size = int(0.2 * len(normalized_data))<br>validation_size = len(normalized_data) - train_size - test_size<br><br># divide os dados nos tamanhos definidos acima<br>train_data = normalized_data[:train_size]<br>test_data = normalized_data[train_size:train_size + test_size]<br>validation_data = normalized_data[train_size + test_size:]<br><br># salva os conjuntos de dados em arquivos CSV sem a header<br>train_data.to_csv(&#39;houses_train_data.csv&#39;, index=False, header=False)<br>test_data.to_csv(&#39;houses_test_data.csv&#39;, index=False, header=False)<br>validation_data.to_csv(&#39;houses_validation_data.csv&#39;, index=False, header=False)<br><br># upload dos arquivos CSV para o bucket S3<br>s3.upload_file(&#39;houses_train_data.csv&#39;, bucket, &#39;houses_train_data.csv&#39;)<br>s3.upload_file(&#39;houses_test_data.csv&#39;, bucket, &#39;houses_test_data.csv&#39;)<br>s3.upload_file(&#39;houses_validation_data.csv&#39;, bucket, &#39;houses_validation_data.csv&#39;)<br><br># caminhos S3 para os dados<br>train_data_path = f&#39;s3://{bucket}/houses_train_data.csv&#39;<br>test_data_path = f&#39;s3://{bucket}/houses_test_data.csv&#39;<br>validation_data_path = f&#39;s3://{bucket}/houses_validation_data.csv&#39;</pre><h3>5. Realizando Training Jobs</h3><p>Agora nós vamos finalmente realizar os “Training Jobs” para descobrir os melhores parâmetros para o nosso modelo.</p><p>Primeiramente, vamos criar objetos de Treinamento do SageMaker para os nossos dados, com base nos caminhos definidos no código acima.</p><pre>from sagemaker.inputs import TrainingInput<br><br># configuracao da entrada de dados para treinamento, teste e validação<br>s3_input_train = TrainingInput(s3_data=train_data_path, content_type=&#39;text/csv&#39;)<br>s3_input_validation = TrainingInput(s3_data=validation_data_path, content_type=&#39;text/csv&#39;)<br>s3_input_test = TrainingInput(s3_data=test_data_path, content_type=&#39;text/csv&#39;)</pre><p>Agora precisamos criar um Estimator , um componente fundamental do SageMaker que permite treinar e implantar modelos de ML de forma simplificada na infraestrutura da AWS.</p><ul><li>O entry_point refere-se ao nosso script de treinamento, o que criamos lá no começo.</li><li>role é um parâmetro que especifica o papel do IAM que concede permissões ao SageMaker para acessar recursos da AWS, como dados armazenados no S3.</li><li>instance_count e instance_type são os parâmetros que vão definir quantas instancias usaremos pra treinar o modelo e qual o tipo delas.</li><li>image_uri especifica a URI da imagem Docker que contém o ambiente de execução para o algoritmo de ML. Aqui, estamos usando a URI da imagem mais recente do XGBoost disponível na região atual da sessão SageMaker.</li><li>sagemaker_sessionespecifica a sessão do SageMaker que será usada para interagir com os serviços da AWS. Nesse caso, estamos utilizando a sessão padrão.</li></ul><pre>from sagemaker.estimator import Estimator<br>from sagemaker import get_execution_role<br><br># obtem o papel IAM<br>role = get_execution_role()<br><br># criacao do estimador SageMaker com o script de treinamento do XGBoost<br>estimator = Estimator(entry_point=&#39;train_script.py&#39;,<br>                      role=role,<br>                      instance_count=1,<br>                      instance_type=&#39;ml.m5.large&#39;,<br>                      image_uri=sagemaker.image_uris.retrieve(&quot;xgboost&quot;, boto3.Session().region_name, &quot;latest&quot;),<br>                      sagemaker_session=sagemaker.Session())</pre><p>E agora, precisamos especificar quais parâmetros queremos otimizar. Lembram-se dos parâmetros que definimos no arquivo ‘training_script.py’? Chegou a hora de determinar em que intervalos esses parâmetros serão testados. Para isso, usamos o HyperparameterTuner do SageMaker, que nos permite definir essas variações.</p><p><strong>É importante lembrar que definir os parâmetros de um modelo não é uma tarefa simples. Utilizar intervalos muito amplos sem uma compreensão dos melhores valores pode ser um tiro no pé, mesmo utilizando a HPO. É interessante avaliar cuidadosamente a base de dados e ajustar os parâmetros gradualmente para encontrar os intervalos mais apropriados.</strong></p><pre>from sagemaker.tuner import HyperparameterTuner, IntegerParameter, ContinuousParameter<br><br># hiperparametros para otimizacao<br>hyperparameter_ranges = {<br>    &#39;max_depth&#39;: IntegerParameter(3, 10),<br>    &#39;eta&#39;: ContinuousParameter(0.01, 0.3),<br>    &#39;min_child_weight&#39;: ContinuousParameter(1, 10),<br>    &#39;subsample&#39;: ContinuousParameter(0.5, 0.9),<br>    &#39;gamma&#39;: ContinuousParameter(0, 0.5),<br>    &#39;num_round&#39;: IntegerParameter(50, 500)<br>}</pre><p>Também precisamos definir a métrica que utilizaremos para avaliar o desempenho do modelo. Neste caso, optamos pelo RMSE. Além disso, é importante especificar que queremos minimizar essa métrica, pois <strong>como o RMSE determina o erro do modelo, quanto menor o seu valor, melhor.</strong></p><p>Outra coisa importante é definir o número máximo de Jobs, ou seja, quantas vezes o script será executado e quantas execuções simultaneamente. No caso, configuramos 20 Jobs, com 2 deles sendo executados simultaneamente.</p><pre># configuracao da otimizacao de hiperparametros<br>objective_metric_name = &#39;validation:rmse&#39; <br>objective_type = &#39;Minimize&#39;<br>metric_definitions = [{&#39;Name&#39;: &#39;validation:rmse&#39;, &#39;Regex&#39;: &#39;validation:rmse: ([0-9\\.]+)&#39;}]<br><br>max_jobs = 20<br>max_parallel_jobs = 2</pre><p>Por fim, vamos criar o Tuner usando as definições que fizemos acima e iniciar a otimização dos parâmetros, fornecendo os dados de treinamento, teste e validação para o Tuner. Esses dados também foram configurados anteriormente.</p><p>O Tuner explorará diferentes combinações de hiperparâmetros e treinará modelos usando essas combinações para encontrar aquela que minimiza o RMSE, conforme definido anteriormente como nossa métrica objetivo.</p><pre># cria o tuner com a definicao da metrica<br>tuner = HyperparameterTuner(estimator,<br>                            objective_metric_name,<br>                            hyperparameter_ranges,<br>                            metric_definitions,<br>                            objective_type=objective_type,<br>                            max_jobs=max_jobs,<br>                            max_parallel_jobs=max_parallel_jobs)<br>print(s3_input_test)<br><br># inicia a hpo e fornece os dados de treinamento, teste e validacao<br>tuner.fit({&#39;train&#39;: s3_input_train, &#39;test&#39;: s3_input_test, &#39;validation&#39;: s3_input_validation})</pre><p>Depois de executar todo esse script acima, podemos retornar ao SageMaker Studio e visualizar os Jobs que executamos e seus status (se estão em andamento, concluídos ou se ocorreu algum erro). Ao abrir um Job, podemos verificar o desempenho do modelo com base na métrica escolhida e os parâmetros que foram usados pelo SageMaker para alcançar esse resultado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1014/1*ZXaDuhvLOIINRwA8IA2eDw.png" /><figcaption>Lista com os Training Jobs Executados</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1014/1*zm8Cz-0KJvdw64odjxJOnA.png" /><figcaption>Performance do modelo, onde o RMSE no conjunto de treino = 0.0618 e no conjunto de validação = 0.0810</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/999/1*3Xb05BSvR_oMfFp1aWeeaQ.png" /><figcaption>Parâmetros usados pelo modelo para atingir o resultado mostrado acima</figcaption></figure><h3>6. Verificando qual o Job que se destacou</h3><p>Para finalizar, vamos ver os resultados dos nossos Jobs via código e descobrir qual foi o que obteve a menor métrica. Muitas vezes, temos modelos que se saem muito bem no conjunto de treino, mas nem tanto no conjunto de validação. Por isso, é interessante puxarmos as metricas para ambos conjuntos e analisarmos.</p><p>O script abaixo se conecta ao SageMaker e puxa os ultimos 30 Training Jobs. Depois disso, acessa informações como seu nome, status e por fim, as métricas.</p><pre>import boto3<br>import pandas as pd<br>from rich import print<br><br># conecta ao sagemaker<br>sagemaker_client = boto3.client(&#39;sagemaker&#39;)<br><br># lista os training jobs (os ultimos 20)<br>response = sagemaker_client.list_training_jobs(<br>    MaxResults=20,  # número maximo de jobs <br>    SortBy=&#39;CreationTime&#39;,  # ordena por data de criacao<br>    SortOrder=&#39;Descending&#39;  # ordena em ordem decrescente para obter os jobs mais recentes primeiro<br>)<br><br>training_jobs = response[&#39;TrainingJobSummaries&#39;]<br><br># extrai infos relevantes dos jobs<br>job_info = []<br>for job in training_jobs:<br>    job_name = job[&#39;TrainingJobName&#39;]<br>    job_arn = job[&#39;TrainingJobArn&#39;]<br>    job_status = job[&#39;TrainingJobStatus&#39;]<br>    <br>    # obtem metricas de desempenho se o job estiver concluido<br>    if job_status == &#39;Completed&#39;:<br>        metrics_response = sagemaker_client.describe_training_job(<br>            TrainingJobName=job_name<br>        )<br><br>        # extrai a metrica de interesse (nesse caso, rMSE)<br>        metric = metrics_response[&#39;FinalMetricDataList&#39;][0]  # selecionando metricas (teste)<br>        metric_value = metric[&#39;Value&#39;]<br><br>        metric_V = metrics_response[&#39;FinalMetricDataList&#39;][1]  # selecionando metricas (validacao)<br>        metric_value_V = metric_V[&#39;Value&#39;]<br>        <br>        job_info.append({&#39;JobName&#39;: job_name, &#39;rmseTrain&#39;: metric_value, &#39;rmseValidation&#39;: metric_value_V})<br><br># converte os resultados em um DataFrame pandas para facilitar a analise<br>df = pd.DataFrame(job_info)<br><br># encontra melhor modelo com base na metrica<br>best_model_train = df[df[&#39;rmseTrain&#39;] == df[&#39;rmseTrain&#39;].min()]<br>best_model_validation = df[df[&#39;rmseValidation&#39;] == df[&#39;rmseValidation&#39;].min()]<br><br>print(f&#39;Melhor modelo (treino): {best_model_train}&#39;)<br>print(&#39;&#39;)<br>print(f&#39;Melhor modelo (validacao): {best_model_validation}&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/791/1*ygWFtJG3NidRE5kWw5wdnw.png" /></figure><p>Veja que, nesse caso, o melhor modelo foi o <strong>xgboost-240522–1341–008-a09c56a5</strong>. Ele obteve a menor métrica tanto para o conjunto de teste, quanto para o conjunto de validação.</p><p>A partir desses resultados, podemos avaliar se o modelo atende às expectativas realizando mais testes ou dar um passo para trás e aumentar o número de Jobs, ajustar os intervalos dos parâmetros ou até mesmo explorar outras arquiteturas de modelos para tentar atingir uma métrica ainda menor.<strong> A otimização de parâmetros nos ajuda bastante, mas existe muito trabalho pela frente, até o deploy do modelo ideal.</strong></p><h3>Fim. Muitos temas foram abordados, como…</h3><ul><li>Utilização do StandardScaler para normalizar os dados antes do treinamento do modelo;</li><li>Divisão os conjuntos de dados em treino, teste e validação e envio desses dados para o serviço de armazenamento S3 da AWS;</li><li>Configuração de um estimador SageMaker para usar o algoritmo XGBoost;</li><li>Especificação dos intervalos para cada hiperparâmetro que seriam otimizado durante o treinamento;</li><li>A instanciação do HyperparameterTuner para otimizar os hiperparâmetros do modelo;</li><li>Como recuperar e avaliar os últimos Training Jobs realizados.</li></ul><p><a href="https://github.com/liviaalvzs/hpo-with-sagemaker">Acesse aqui o repositório desse projeto!</a> 😺</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8ed136efee7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Plotando um mapa interativo com informações do metrô de São Paulo usando Python]]></title>
            <link>https://medium.com/@alvzslivia/plotando-um-mapa-interativo-com-informa%C3%A7%C3%B5es-do-metr%C3%B4-de-s%C3%A3o-paulo-usando-python-b0470d8d0b10?source=rss-493a7252640d------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0470d8d0b10</guid>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Lívia Alves]]></dc:creator>
            <pubDate>Thu, 20 Apr 2023 16:56:22 GMT</pubDate>
            <atom:updated>2024-10-01T19:09:46.003Z</atom:updated>
            <content:encoded><![CDATA[<p>O Python é uma linguagem que possui bibliotecas incríveis e com capacidade de criar projetos de praticamente qualquer interesse. Nesse artigo vou mostrar <strong>como lidar com dados geoespaciais para criar um mapa interativo do zero</strong>. O mapa aqui criado vai conter informações de todas as linhas e estações de trem/metrô de São Paulo.</p><p>💻 <a href="https://liviaalvzs.github.io/metro-sp">Clique aqui</a> e veja esse projeto rodando no seu navegador.</p><p>📁 <a href="https://github.com/liviaalvzs/data-repository/blob/main/projeto-metro-sp/notebook.ipynb">Clique aqui</a> e confira o repositório com todo o código.</p><h3>1. As bibliotecas que serão usadas</h3><p>Para realizar esse projeto algumas bibliotecas serão necessárias:</p><h4><strong>1.1 Geopandas</strong></h4><p>É uma biblioteca voltada para a análise de dados geoespaciais e foi construída sobre as bibliotecas Pandas, Matplotlib e Shapely. O Geopandas fornece ferramentas muito interessantes para trabalhar com esse tipo de dado, permitindo que os usuários os manipulem e visualizem de forma eficiente.</p><h4><strong>1.2 Folium</strong></h4><p>Essa biblioteca permite a criação de mapas interativos e estilizados em formato HTML, usando dados geoespaciais. Ela é construída sobre a biblioteca de visualização de dados Leaflet.js e fornece uma interface simples e fácil de usar para criar mapas interativos no Python.</p><h4>1.3 Json</h4><p>Com essa biblioteca é possível codificar objetos em JSON (que é o que vamos fazer mais para frente) e decodificar dados JSON em objetos Python. Ela é bem simples mas muito útil ao trabalhar com esse tipo de dado no Python.</p><pre>import geopandas as gpd<br>import folium<br>import json</pre><h3>2. Obtendo os dados</h3><p>O dataset que usaremos é o <strong>Transporte Metroferroviário — Região Metropolitana de São Paulo — 2021</strong>, que é disponibilizado no Centro de Estudos da Metrópole, mantido pela FFLCH, da USP.</p><ul><li><strong>🚇 </strong><a href="https://centrodametropole.fflch.usp.br/pt-br/file/17846/download?token=ybw7O3f1"><strong>Clique aqui</strong></a> para baixar os dados.</li><li>📥 <a href="https://centrodametropole.fflch.usp.br/pt-br/download-de-dados"><strong>Clique aqui</strong></a> para conferir outros datasets disponibilizados, que podem ser úteis em outros projetos de estudo.</li></ul><p>Após extrair os arquivos e os inserir na pasta onde vamos trabalhar, podemos começar a explorá-los.</p><blockquote>Eu tenho preferência de trabalhar no VSCode usando um Jupyter Notebook, mas esse projeto pode ser feito na IDE de sua preferência usando um notebook ou um arquivo python padrão.</blockquote><h3>3. Plotando o Mapa</h3><h4>3.1 Explorando e Tratando os Dados: .shp para .geojson</h4><p>Primeiramente, eu recomendo uma passada pelo arquivo .pdf que foi baixado junto com os dados, é uma documentação importante para entender o que cada arquivo representa. Nesse projeto, nós vamos usar:</p><ul><li><strong>MetL_2021_CEM.shp</strong> -&gt; informações das linhas de trem/metrô</li><li><strong>MetE_2021_CEM.shp </strong>-&gt; informações das estações de trem/metrô</li></ul><p>O primeiro passo é <strong>importar esses dados no formato geoDataFrame</strong>, para que possamos visualizá-los e entendê-los.</p><pre>linhas_dataframe = gpd.read_file(&#39;Transporte Metroviário 2021 CEM/MetL_2021_CEM.shp&#39;)<br>estacoes_dataframe = gpd.read_file(&#39;Transporte Metroviário 2021 CEM/MetE_2021_CEM.shp&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bowcs7flw-mwCb5Zd_00jQ.png" /></figure><p>A estrutura geoDataFrame é, como o nome já diz, algo bem parecido com um dataFrame normal do Pandas. Podemos analisar linhas, colunas, gerar estatísticas dependendo do tipo de campo e etc. É um bom meio para entender como os dados se organizam e isolar informações específicas, que é algo que será feito mais pra frente.</p><p>O próximo passo é converter ambos geoDataFrames para um arquivo .geojson, para que seja possível plotar esses dados com eficiência no nosso mapa usando o Folium.</p><pre># escreve arquivo &quot;linhas.geojson&quot; com os dados do geoDataFrame<br>linhas_dataframe.to_file(&quot;linhas.geojson&quot;, driver = &quot;GeoJSON&quot;)<br>with open(&quot;linhas.geojson&quot;) as geofile:<br>    j_file = json.load(geofile)<br><br><br># escreve arquivo &quot;estacoes.geojson&quot; com os dados do geoDataFrame <br>estacoes_dataframe.to_file(&quot;estacoes.geojson&quot;, driver = &quot;GeoJSON&quot;)<br>with open(&quot;estacoes.geojson&quot;) as geofile:<br>    j_file = json.load(geofile)</pre><p>Após rodar esse código, dois arquivos serão criados na pasta do projeto: linhas.geojson e estacoes.geojson.</p><pre>linhas = &#39;linhas.geojson&#39;<br>estacoes = &#39;estacoes.geojson&#39;</pre><h4>3.2 Entendendo como plotar mapas com o Folium</h4><p>Plotar um mapa com essa biblioteca é muito simples. A linha abaixo, por exemplo, gera um mapa centralizado em São Paulo, mas que é interativo e pode ser explorado com ferramentas de zoom-in, zoom-out e também ao arrastar o mouse pelas regiões.</p><pre>m = folium.Map(location=([-23.533773, -46.625290]))</pre><p>Também é possível gerar mapas com diferentes estilos. O que vou usar nesse projeto é o cartodbdark_matter mas existem diversos modelos a serem explorados.</p><pre>m = folium.Map(location=([-23.533773, -46.625290]))<br>folium.TileLayer(&#39;cartodbdark_matter&#39;).add_to(m)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DzSD1fXIoBXCLDm7V7keAw.png" /></figure><h4>💡 Como ver o mapa que estou criando?</h4><p>Caso você esteja usando algum tipo de notebook, como o Jupyter, por exemplo, basta chamar a variável que está guardando o nosso objeto folium.Map() , no caso m .</p><p>Se estiver codando em um arquivo .py ou mesmo se apenas quiser ver esse mapa em uma página em seu navegador, é possível usar a função save(&#39;nome_do_arquivo.html&#39;) em cima do objeto e abrir o arquivo .html criado na sua pasta de trabalho.</p><pre># para o caso de estar se usando um notebook e querer ver na própria IDE<br>m<br># para o caso de querer abrir em uma página web<br>m.save(&#39;mapa.html&#39;)</pre><h4>3.3 Inserindo os dados das linhas de trem/metrô em mapas</h4><p>Para fazer isso, vamos usar a função folium.GeoJson() . Vamos passar, como parâmetro, o caminho do nosso arquivo (que atribuímos para as variáveis linhas e estacoes) e qual coluna queremos que seja mostrada no efeito mouseover. Para esse segundo item, escolhi a coluna NM_COR , que contém as cores de cada linha.</p><pre>m = folium.Map(location=([-23.533773, -46.625290]))<br>folium.TileLayer(&#39;cartodbdark_matter&#39;).add_to(m)<br><br>folium.GeoJson(linhas,<br>               tooltip=folium.GeoJsonTooltip(fields=[&#39;NM_COR&#39;])<br>              ).add_to(m)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ShGGKCRkrCQ-rIASSf-T-w.png" /></figure><p>É possível fazer o mesmo mas com os dados das estações, mudando ambos parâmetros citados acima ( linhas -&gt; estacoes e NM_COR -&gt; NM_EST )</p><pre>m = folium.Map(location=([-23.533773, -46.625290]))<br><br>folium.TileLayer(&#39;cartodbdark_matter&#39;).add_to(m)<br><br>folium.GeoJson(estacoes, name=&#39;geojson&#39;, <br>               tooltip=folium.GeoJsonTooltip(fields=[&#39;NM_EST&#39;])<br>              ).add_to(m)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_w_4gwNm1F38wt4gHTOblQ.png" /></figure><h4>3.4 Personalizando o estilo de exibição dos dados</h4><p>Agora é necessária algumas mudanças de estilização, para possibilitar uma melhor visualização dos dados. Começando pelas linhas, vamos identificá-las pelas suas respectivas cores. A melhor estrutura para esse tipo de coisa é um dicionário, que criaremos na mão:</p><ul><li>Primeiramente, vamos criar uma lista com o nome de cada linha a partir de uma coluna do nosso geoDataFrame.</li><li>Depois, criaremos uma lista com as cores de cada uma das linhas.</li><li>Por fim, vamos juntar ambas listas em um dicionário, onde a chave é o nome da linha e o valor, a sua cor.</li></ul><pre># salva os nomes das linhas de trem/metrô (coluna &quot;NM_COLOR&quot;) em um array <br>names = list(linhas_dataframe[&#39;NM_COR&#39;])<br><br># define as cores de cada linha<br>colors = [<br>    &#39;#00a78e&#39;, # esmeralda 9<br>    &#39;#716eb3&#39;, # lilás 5<br>    &#39;#a5a698&#39;, # diamante 8<br>    &#39;#fec422&#39;, # amarela 4<br>    &#39;#ca006c&#39;, # rubi 7<br>    &#39;#008da8&#39;, # turquesa 10 <br>    &#39;#a8a9ad&#39;, # prata 15 <br>    &#39;#009b7b&#39;, # verde 2 <br>    &#39;#0079c2&#39;, # azul 1 <br>    &#39;#e51836&#39;, # vermelha 3<br>    &#39;#103e8c&#39;, # safira 12<br>    &#39;#21b159&#39;, # jade 13<br>    &#39;#f47320&#39;, # coral 11<br>    ]<br><br># cria um dicionário que vai armazenar os nomes das linhas de trem/metrô e suas cores (nome:cor)<br>dict_colors = {names[i]: colors[i] for i in range(len(names))}</pre><p>Agora vamos criar uma função que receberá um objeto do nosso .geojson, e de acordo com o item no atributo NM_COR, iterará sob o dicionário e retornará a sua respectiva cor.</p><pre>def get_colors(feature, dict):<br>    for color_name in dict_colors:<br>        if feature[&#39;properties&#39;][&#39;NM_COR&#39;] == color_name:<br>            return dict_colors[color_name]</pre><p>Agora essa função será adicionada na parte em que plotamos os dados no mapa, da seguinte forma:</p><pre>m = folium.Map(location=([-23.533773, -46.625290]))<br>folium.TileLayer(&#39;cartodbdark_matter&#39;).add_to(m)<br><br>folium.GeoJson(linhas, name=&#39;geojson&#39;, <br>               tooltip=folium.GeoJsonTooltip(fields=[&#39;NM_COR&#39;]),<br>               style_function = lambda feature: {&#39;color&#39;:get_colors(feature, dict_colors), &#39;weight&#39;:4.5}<br>              ).add_to(m)</pre><p>No código acima também foi adicionado o parâmetro, weight, que corresponde à espessura das linhas plotadas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x4n5ipzjXdEJBbXOevg4Ig.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vq-KutpsAah-mNic3xtnfg.png" /></figure><p>Agora vamos fazer algumas mudanças para as estações:</p><pre>m = folium.Map(location=([-23.533773, -46.625290]))<br>folium.TileLayer(&#39;cartodbdark_matter&#39;).add_to(m)<br><br>folium.GeoJson(estacoes, <br>               name=&#39;geojson&#39;, <br>               marker=folium.Circle(radius=30, fill_color=&quot;red&quot;, fill_opacity=0.3, color=&quot;white&quot;, weight=2),<br>               tooltip=folium.GeoJsonTooltip(fields=[&#39;NM_EST&#39;], aliases=[&#39;ESTAÇÃO:&#39;], style=(&quot;background-color: grey; color: white; font-size: 15px&quot;)), <br>              ).add_to(m)</pre><p>No código acima, a função folium.Circle()contém os parâmetros dos marcadores que inserimos para cada estação, como seu tamanho, a cor de preenchimento, opacidade, cor da borda e a espessura da borda. Além disso, na função folium.GeoJsonTooltip(), foi inserido o parâmetro aliases , com o texto a ser exibido antes do nome da estação, como também o parâmetro style , com novas especificações para essa caixa de texto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3-gKmKZCPzjnEfEdEOsNEA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PCl2wTwpTEZex4RNxbQayQ.png" /></figure><h4>3.4 Plotando todas as informações em um único mapa</h4><p>Para ter acesso às duas informações (linhas e estações) em um plot só, podemos simplesmente juntar ambos scripts que vínhamos escrevendo no item anterior.</p><pre>m = folium.Map(location=([-23.533773, -46.625290]))<br>folium.TileLayer(&#39;cartodbdark_matter&#39;).add_to(m)<br><br>folium.GeoJson(linhas, <br>               name = &#39;geojson&#39;, <br>               tooltip = folium.GeoJsonTooltip(fields=[&#39;NM_COR&#39;, &#39;OPERACAO&#39;], aliases=[&#39;LINHA:&#39;, &#39;OPERAÇÃO:&#39;], style=(&quot;background-color: grey; color: white; font-size: 15px&quot;)),<br>               style_function = lambda feature: {&#39;color&#39;:get_colors(feature, dict_colors), &#39;fillOpacity&#39;:0.9, &#39;weight&#39;:4.5}<br>              ).add_to(m)<br><br>folium.GeoJson(estacoes, name=&#39;geojson&#39;, marker=folium.Circle(<br>                   radius = 30,<br>                   fill_color = &quot;red&quot;,<br>                   fill_opacity = 0.3,<br>                   color = &quot;white&quot;,<br>                   weight = 2),<br>                   tooltip = folium.GeoJsonTooltip(fields=[&#39;NM_EST&#39;, &#39;INICIO&#39;, &#39;DISTRITO&#39;], aliases=[&#39;ESTAÇÃO:&#39;, &#39;INICIO:&#39;, &#39;DISTRITO:&#39;], style=(&quot;background-color: grey; color: white; font-size: 15px&quot;)), <br>              ).add_to(m)</pre><p>No código acima, temos duas funções folium.GeoJson() sendo referenciadas ao mesmo mapa m , uma chamando o arquivo de linhas e o outro o de estações. Isso vai fazer com que ambas informações apareçam no mesmo mapa.</p><p>Além disso, na função folium.GeoJsonTooltip() foram adicionados mais colunas no campo fields e seus respectivos títulos no campo aliases , que são os dados que serão exibidos no ato de passar o mouse por cima de uma linha ou estação.</p><h3>Resultado Final:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NS3RKWSZm-LqL-cy3h8oQw.gif" /></figure><h4>Valeu por chegar até aqui!</h4><p>Apesar de esse não ser um projeto super complexo, sem dúvidas o resultado final fica bem legal e agrega bastante valor em questao de aprendizado. Só com ele foi possível explorar muitas coisas interessantes, como:</p><ul><li>A conversão de dados .shp para .geojson;</li><li>Realização de análise de dados geoespaciais usando a biblioteca Geopandas e a estrutura geoDataFrame;</li><li>Criação de um mapa usando a biblioteca Folium;</li><li>A exploração da função folium.tyleLayler() para criar uma camada personalizada para o mapa;</li><li>Adição de camadas de dados no mapa, sejam eles no formato lines ou markers ;</li><li>A personalização dos dados adicionados no mapa para gerar uma melhor visualização ao usuário;</li><li>Exploração da função folium.GeoJsonTooltip() para a inserção de informações sobre o dado plotado. Isso gera valor ao usuário e para análise que este poderá fazer a partir do plot que criamos.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0470d8d0b10" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Usando Python Para Lidar com Dados Geoespaciais]]></title>
            <link>https://medium.com/@alvzslivia/usando-python-para-lidar-com-dados-geoespaciais-1d14c0aba6c3?source=rss-493a7252640d------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d14c0aba6c3</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[português]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[xarray]]></category>
            <dc:creator><![CDATA[Lívia Alves]]></dc:creator>
            <pubDate>Thu, 09 Mar 2023 13:44:45 GMT</pubDate>
            <atom:updated>2024-10-01T19:01:14.925Z</atom:updated>
            <content:encoded><![CDATA[<p>Atualmente, o Python é a linguagem mais popular e amplamente utilizada quando se trata de manipulação e tratamento de dados, possuindo diversas bibliotecas específicas para essa finalidade. Esse artigo tem como objetivo mostrar como lidar com dados geoespaciais, usando a biblioteca Xarray.</p><h3>O que é o Xarray?</h3><p>É uma biblioteca Python projetada para trabalhar com dados de matriz N-dimensional, e é isso que a torna uma boa ferramenta para lidar com dados geoespaciais. A sua instalação é feita como qualquer outra biblioteca da linguagem: pip install xarray</p><h3>Obtendo um dataset com dados de previsão de tempo</h3><p>Para fins de teste e demonstração, será usado um dataset do modelo GFS de previsão de tempo. O dataset com a previsão mais recente pode ser obtido usando a função abaixo, mas o que aqui for mostrado pode ser usado em qualquer arquivo .grib ou .nc, com suas devidas adaptações a depender da estrutura de dados.</p><pre>import xarray as xr<br>from datetime import datetime<br><br>def get_gfs_data(date, hour):<br>    &#39;&#39;&#39;<br>    Função que baixa os dados de precipitação do GFS (0.25°)<br>    Date = objeto do tipo datetime indicando a data<br>    Hour = Hora da rodada, com dois dígitos<br>    &#39;&#39;&#39;<br>    date = date.strftime(&#39;%Y%m%d&#39;)<br>    url = F&#39;https://nomads.ncep.noaa.gov/dods/gfs_0p25/gfs{date}/gfs_0p25_{hour}z&#39;<br>    ds = xr.open_dataset(url)<br>    return ds<br><br>ds = get_gfs_data((datetime.today()), &#39;00&#39;)</pre><h3>Explorando o dataset com Xarray</h3><p>Agora que temos um dataset, podemos começar a explorar as principais funções do Xarray e aprender a manipular os dados.</p><h4>Abrindo um dataset com Xarray</h4><p>Na função get_gfs_data() , apresentada no tópico anterior, foi mostrado como abrir o dataset com Xarray a partir de uma URL, utilizando a função open_dataset() . Ela pode ser usada para abrir, além de URL’s, arquivos .nc e .grib, da seguinte forma:</p><pre>import xarray as xr<br><br># abrindo uma url<br>url = &#39;www.abcde.com.br/fghi&#39;<br>ds = xr.open_dataset(url)<br><br># abrindo um arquivo .nc<br>path = &#39;pasta/arquivo.nc&#39;<br>ds = xr.open_dataset(path)<br><br># abrindo um arquivo .grib<br>path = &#39;pasta/arquivo.grib2&#39;<br>ds = xr.open_dataset(path, engine=&#39;cfgrib&#39;)</pre><h4>Entendendo a estrutura de dados</h4><p>Como já mencionado, o Xarray é utilizado para lidar com dados multidimensionais. Ao abrir a variável ds , obtida anteriormente a partir da função get_gfs_data(), podemos ver esse dataset possui dimensões de 129 x 41 x 721 x 1440, correspondentes às variáveis de time, lev, lat e lon. Também pode-se verificar que ele possui 215 variáveis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*dlm8JO9Z8NT36lU4wv2Tkg.png" /><figcaption>Exibição do dataset</figcaption></figure><p>Podemos usar .coords e .data_vars para verificar as variáveis e as coordenadas desse dataset:</p><pre># verificando as coordenadas<br>ds.coords<br><br># verificando as variáveis<br>ds.data_vars</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*ArIq8hHKsWFj0JXsLW-OEg.png" /><figcaption>Exibição das coordenadas e de algumas das variáveis do dataset</figcaption></figure><p>Isso quer dizer que <strong>para cada uma das variáveis, para cada tempo, combinado com o nível, latitude e longitude, existe um valor.</strong> E é mais ou menos assim que a grande maioria dos dados meteorológicos, por exemplo, funcionam.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/0*9ST7cNjrC-aui0Xa.png" /><figcaption>Imagem retirada da documentação do xarray</figcaption></figure><h4>Isolando a variável de precipitação</h4><p>Para fazer o restante dos testes, é interessante isolar uma das 215 variáveis que possuímos. Por meio da documentação do GFS é possível entender o que cada variável representa, e a que representa a precipitação (em kg/m²/s) é chamada de prateavesfc<strong> . </strong>Sendo assim, vamos isolá-la.</p><pre>prec = ds.prateavesfc</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/777/1*AclBJv0u2i-_83SFeikDQA.png" /><figcaption>Exibição do dataArray com os dados de precipitação</figcaption></figure><p>Perceba que agora as dimensões são de 129 x 721 x 1440. Isso ocorre porque como essa variável refere-se à taxa de precipitação na superfície, ela não é observada por níveis, então essa dimensão foi descartada. Isso pode acontecer em diversos cenários — <strong>algumas variáveis podem ou não seguir exatamente a mesma estrutura dentro de um mesmo dataset.</strong></p><h4>Isolando dados de precipitação de um tempo, latitude, ou longitude específica</h4><p>Para isolar um tempo específico podemos usar a indexação ou a função sel() .</p><p>⚠️ Importante lembrar que o GFS disponibiliza as previsões para intervalos de 3h em 3h e que os de precipitação são em kg/m²/s</p><pre># isolando o primeiro tempo usando indexação<br>first_three_hours = prec[0]<br><br># isolando o primeiro dia usando indexação<br>first_day = prec[0:9]<br><br># isolando o primeiro dia usando .sel()<br>inicio = datetime(2023, 3, 8)<br>fim = datetime(2023, 3, 9)<br>d1 = inicio.strftime(&quot;%Y-%m-%d&quot;); <br>d2= fim.strftime(&quot;%Y-%m-%d&quot;)<br><br>first_day = prec.sel(time=slice(d1+&#39;T00&#39;, d2+&#39;T00&#39;))</pre><p>Para isolar dados de uma localização específica, a solução é basicamente a mesma:</p><pre>slicing_coords = prec.sel(lat=slice(-90, 0), lon=slice(0, 25))</pre><h4>Isolando valores específicos das coordenadas</h4><p>Obter o valor de determinada coordenada pode ser bem útil em alguns casos e pode ser feito da seguinte forma:</p><pre># obtendo o valor de time -&gt; retorna um objeto do tipo numpy.datetime64<br>date = prec[0].time.values<br><br># para obter o valor de alguma outra coordenada, basta trocar time pelo <br># nome da variável, como lat, lon e etc. se essa variável não estiver <br># isolada, o retorno será um array com todas elas.</pre><h4>Realizando operações com o dataset</h4><p>Também é possível realizar operações com os nossos dados, como média, subtração, encontrar o valor mínimo ou máximo e etc.</p><pre># isolando o primeiro dia usando indexação<br>first_day = prec[0:9]<br><br># encontrando a média dos dados de precipitação<br>first_day.mean(dim=&#39;time&#39;)<br><br># obtendo um acumulado de precipitação<br>first_day.sum(dim=&#39;time&#39;)<br><br># obtendo os valores máximos de precipitação <br>first_day.max(dim=&#39;time&#39;) </pre><p>Também é possível isolar valores de latitude e longitude específicos e ver como os valores de precipitação se comportam com o passar do tempo, além de também realizar operações:</p><pre>import random<br><br># selecionando um valor aleatório dentre as latitudes e longitudes<br>random_lat = random.choice(first_day.lat.values)<br>random_lon = random.choice(first_day.lon.values)<br><br># selecionando os dados correspondentes à latitude e longitude mapeados <br># aleatóriamente acima<br>random_loc = first_day.sel(lat=(random_lat), lon=(random_lon))<br><br># a variável random_loc já corresponde ao comportamento da precipitação em <br># relação ao tempo nessa localização<br>random_loc.values<br><br># obtendo valor máximo de precipitação nessa localização<br>random_loc.max().values<br><br># obtendo média da precipitação nessa localização<br>random_loc.mean().values</pre><h4>Links interessantes para aprender mais</h4><ul><li><a href="https://docs.xarray.dev/en/stable/examples/multidimensional-coords.html">Documentação do Xarray</a></li><li><a href="https://tutorial.xarray.dev/intro.html">Xarray Tutorial</a></li><li><a href="https://rabernat.github.io/research_computing/xarray.html">Xarray for Multidimensional Data</a></li><li><a href="https://medium.com/towards-data-science/read-netcdf-data-with-python-901f7ff61648">Read NetCDF Data with Python</a></li><li><a href="https://training.digitalearthafrica.org/en/latest/python_basics/05_xarray.html">Learning Xarray</a></li></ul><h4>Fim! :)</h4><p>Esse artigo, apesar de simples, passou pelos seguintes tópicos:</p><ul><li>O que é o xarray?</li><li>Como obter um dado de previsão de tempo do modelo GFS</li><li>Como abrir um arquivo .nc ou .grib usando o xarray</li><li>A forma como funciona a estrutura de dados do xarray (dataArray e dataSet)</li><li>Como isolar uma variável dentro de um dataSet e obter um dataArray</li><li>Utilizar indexação ou a função .sel() para fatiar intervalos de tempo ou coordenadas específicas</li><li>Como realizar operações para obter a média, acumulados ou valores máximos em relação ao tempo</li><li>Obter valores aleatórios a partir de um array</li><li>Como isolar uma localização específica e realizar operações como a obtenção da soma, média, acumulados, valores máximos ou mínimos…</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d14c0aba6c3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>