<?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 Pedro César Ribeiro Passos on Medium]]></title>
        <description><![CDATA[Stories by Pedro César Ribeiro Passos on Medium]]></description>
        <link>https://medium.com/@pedrorp?source=rss-4c0cffa176c9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Ol77M4l4u-ynPJdvzvwFVA.png</url>
            <title>Stories by Pedro César Ribeiro Passos on Medium</title>
            <link>https://medium.com/@pedrorp?source=rss-4c0cffa176c9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 23:40:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pedrorp/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[Desvendando Árvores de Decisão em Machine Learning (Parte 1 — Classificação)]]></title>
            <link>https://medium.com/@pedrorp/desvendando-%C3%A1rvores-de-decis%C3%A3o-em-machine-learning-parte-1-classifica%C3%A7%C3%A3o-1ee3d251a616?source=rss-4c0cffa176c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ee3d251a616</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[decision-tree]]></category>
            <dc:creator><![CDATA[Pedro César Ribeiro Passos]]></dc:creator>
            <pubDate>Wed, 28 Jun 2023 06:17:10 GMT</pubDate>
            <atom:updated>2023-06-28T06:17:10.232Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5X7yAj4MkO4Ls9fl1ZkHcQ.png" /></figure><h3>Desvendando Árvores de Decisão em Machine Learning (Parte 1 — Classificação)</h3><p>Este algoritmo é uma das ferramentas mais poderosas no Aprendizado Supervisionado e você com certeza já ouviu falar dele. Neste artigo, iremos entender o funcionamento, a estrutura, as métricas e por fim implementar “from scratch” uma Árvore de Decisão para classificação.</p><h3>Entendendo a Estrutura da Árvore de Decisão</h3><p>A Árvore de Decisão é composta por nós e ramos. Imagine uma árvore de ponta-cabeça: a raiz na parte superior e seus ramos se estendendo para baixo. A “raiz” da árvore é o nó onde tomamos a primeira decisão, por isso o nome “Árvore de Decisão”. Cada ramo é a representação de um resultado possível dessa decisão. E os nós finais (folhas) representam os rótulos de classe finais (ou valor numérico em caso de regressão).</p><ul><li><strong>Nó de Decisão</strong>: Baseia-se em um ou mais atributos (features ou coluna), onde a decisão precisa ser feita.</li><li><strong>Nós Filhos</strong>: São os ramos que seguem um nó, resultados de uma decisão.</li><li><strong>Nó Folha</strong>: São os ramos finais que não se ramificam.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/997/1*8L4L3J1EHAydwK9hVmHl4g.png" /><figcaption>Imagem retirada do site da biblioteca scikit-learn</figcaption></figure><p>Dado um conjunto de variáveis independentes e rótulos (variável dependente), o algoritmo tenta encontrar regras que o permitam dividir os dados de uma forma que a informação obtida seja a maior possível.</p><h3>Medindo a Melhor Decisão: As Métricas.</h3><p>Mas você pode estar se perguntando. “Ok, a gente divide o conjunto a partir de regras. E como as regras são definidas? Como a Árvore de Decisão decide qual melhor recurso para usar? Qual a pergunta certa?”</p><p>A Árvore de Decisão faz essa escolha através de um processo que busca minimizar uma medida chamada <strong><em>impureza</em></strong>, que pode ser calculada de várias maneiras, sendo a Impureza de Gini e a Entropia as mais comuns. Este processo é feito de maneira recursiva, em cada nó da árvore.</p><p>A impureza é uma medida de quão misturados estão os dados em um nó. Se todos os exemplos em um nó pertencem a uma <strong>única classe</strong>, a impureza é <strong>zero</strong>, logo temos um nó “puro”. Mas se os dados são <strong>igualmente divididos entre várias classes, a impureza é alta</strong>.</p><p>Para cada atributo (feature), o algoritmo calcula a impureza para vários pontos de divisão possíveis. O <strong>ponto de divisão</strong> é um valor que divide o conjunto em duas categorias baseadas no fato de serem maiores ou menores que esse valor. A <strong>impureza da divisão</strong> é a média ponderada das impurezas dos dois grupos resultantes.</p><p>O atributo e o ponto de divisão que resultam na menor impureza são selecionados para a divisão. Este processo é repetido recursivamente para cada grupo resultante até que a árvore atinja uma profundidade máxima especificada (<strong><em>max_depth</em></strong>) ou até que a divisão não reduza mais a impureza. Através deste processo, a Árvore de Decisão toma decisões que são ótimas em cada nó de maneira local, para que assim seja encontrada uma solução globalmente ótima. Abaixo, serão listadas as principais métricas usadas para definir a pureza dos nós.</p><h4>Impureza de Gini</h4><p>Mede a frequência com que um elemento aleatório do conjunto seria rotulado de maneira errada se fosse rotulado aleatoriamente de acordo com a distribuição de rótulos no subconjunto. Ou seja, <strong>é a probabilidade de um elemento aleatório ser classificado incorretamente</strong>. Para um conjunto de dados com <strong><em>c</em></strong> classes e <strong><em>pj</em></strong> sendo a frequência relativa da classe <strong><em>j</em></strong> no conjunto, a impureza de Gini <strong><em>IG </em></strong>é calculada por:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/274/1*gZzNjP03nHITvdWGUb-9DA.png" /><figcaption>Imagem encontrada em pesquisas na internet</figcaption></figure><p>Por exemplo, se tivermos um conjunto com 10 elementos, onde 5 são da classe A e 5 são da classe B, a Impureza de Gini seria calculada como:</p><p><em>IG = 1 — [(5/10)² + (5/10)²] = 0.5</em></p><p><strong><em>Esse valor indica que nosso conjunto é impuro, pois contém uma mistura igual de classes A e B.</em></strong></p><h4><strong>Entropia</strong></h4><p>A entropia é outra medida de impureza ou desordem. Para um conjunto de dados com <strong><em>c</em> </strong>classes e <strong><em>pj</em></strong> sendo a frequência relativa da classe <strong><em>j</em></strong> no conjunto, a entropia <strong><em>IH</em></strong> é calculada como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/370/1*g0JeG59CBX7RQWa-yoyEmw.png" /><figcaption>Imagem encontrada em pesquisas na internet</figcaption></figure><p>Por exemplo, se tivermos um conjunto de dados com 10 elementos, 5 da classe A e 5 da classe B, a Entropia seria calculada da seguinte forma:</p><p>entropia = — [(5/10) * log2(5/10) + (5/10) * log2(5/10)] = 1</p><p>A Entropia máxima é 1 (para um sistema com duas classes), que ocorre quando as classes estão igualmente misturadas, ou seja, máxima incerteza ou desordem. A entropia mínima é 0, que ocorre quando todas as instâncias pertencem a uma única classe, indicando que não há incerteza ou desordem.</p><h4><strong>Ganho de Informação</strong></h4><p>É a redução na Entropia após uma divisão do conjunto de dados com base em um atributo. Para um conjunto de dados <strong><em>a</em></strong> dividido em subconjuntos <strong><em>a1, a2, ..., ai </em></strong>baseado em um atributo, e onde <strong><em>|a|</em></strong> denota o número de elementos em <strong><em>a</em></strong>, o ganho de informação <strong><em>Gain(T, a)</em></strong> é calculado como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/873/1*qhnmhmHJKJpcXzHM8L0NEw.png" /><figcaption>Imagem encontrada em pesquisas na internet</figcaption></figure><p>Em resumo, podemos ler a descrição matemática acima como<strong><em> “Ganho de Informação = Entropia do conjunto pai — Σ (Peso da divisão * Entropia da divisão)”</em></strong>. Sendo:</p><ul><li><em>“Entropia do conjunto pai”</em> é a Entropia antes da divisão.</li><li><em>“Peso da divisão”</em> é a proporção de instâncias que vão para cada divisão.</li><li><em>“Entropia da divisão”</em> é a Entropia de cada subconjunto após a divisão.</li></ul><p>Vamos considerar um exemplo onde temos um conjunto de dados com 20 elementos, 10 da classe A e 10 da classe B, e queremos dividir com base em um recurso que resulta em um subconjunto com 7 elementos da classe A e 3 da classe B, e outro subconjunto com 3 elementos da classe A e 7 da classe B. O cálculo do Ganho de Informação vai ser:</p><ol><li>Entropia antes da divisão (conjunto pai):</li></ol><p><em>entropia_pai = — [(10/20) * log2(10/20) + (10/20) * log2(10/20)] = 1</em></p><p>2. Entropia para cada divisão:</p><p><em>entropia_div_1 = — [(7/10) * log2(7/10) + (3/10) * log2(3/10)] = 0.88</em></p><p><em>entropia_div_2 = — [(3/10) * log2(3/10) + (7/10) * log2(7/10)] = 0.88</em></p><p>3. Peso para cada divisão:</p><p><em>peso_div_1 = 10/20 = 0.5</em></p><p><em>peso_div_2 = 10/20 = 0.5</em></p><p>4. Substituição desses valores na fórmula do Ganho de Informação:</p><p><em>ganho_informacao = 1 — [0.5 * 0.88 + 0.5 * 0.88] = 0.12</em></p><p>Pensando em uma situação em que outra forma de uso de recurso resulta em um Ganho de Informação de 0.10, esta seria melhor em relação ao nosso exemplo de 0.12.</p><h3>A limitação do Ganho de Informação</h3><p>Como falado anteriormente, o Ganho de Informação é uma métrica que mede a mudança na Entropia, ou seja, a impureza ou incerteza resultante da divisão de um conjunto de dados com base em um determinado atributo. A ideia é que um bom atributo (feature) para dividir os dados é aquele que reduz a incerteza o máximo possível.</p><p>No entanto, uma limitação do uso do Ganho de Informação como métrica é a sua tendência a favorecer atributos com muitos valores possíveis. Por exemplo, se tivermos um atributo que é único para cada instância em nosso conjunto de dados (como um ID), esse atributo terá um ganho de informação máximo, pois nos permitirá perfeitamente classificar nossos dados. No entanto, esse atributo é claramente inútil para fazer previsões sobre novas instâncias, já que não teremos visto seu valor específico antes.</p><p>Para exemplificar esse problema vamos considerar um exemplo simples com um conjunto de dados de 5 instâncias, onde cada instância tem dois atributos: um ID único e uma cor, que pode ser Vermelho ou Verde. A classe de cada instância é determinada pela cor.</p><pre>ID  | Cor    | Classe<br>----------------------<br>1   | Verde  | 1<br>2   | Verde  | 1<br>3   | Vermelho | 0<br>4   | Vermelho | 0<br>5   | Verde  | 1</pre><p>Se calcularmos o Ganho de Informação para os atributos ID e Cor, obteremos:</p><ul><li>Para o atributo ID, cada valor é único, então para qualquer valor de ID usado para dividir os dados, teremos subconjuntos puros (isto é, com instâncias de uma única classe). <strong>Portanto, o Ganho de Informação será máximo</strong>.</li><li>Para o atributo Cor, se usarmos Verde para dividir os dados, teremos um subconjunto com as instâncias 1, 2 e 5 (todas da classe 1) e outro subconjunto com as instâncias 3 e 4 (todas da classe 0). <strong>Novamente, temos subconjuntos puros, então o ganho de informação também será máximo.</strong></li></ul><p>O problema é o seguinte, se seguirmos o Ganho de Informação, poderíamos escolher o ID como o melhor atributo para dividir os dados, já que ele fornece o mesmo ganho de informação que o atributo Cor. No entanto, não é difícil perceber que o ID é inútil para fazer previsões sobre novas instâncias, já que não teremos visto seu valor específico antes.</p><h4>E qual seria a solução para esse problema?</h4><p>Uma das soluções é o uso de outra métrica, a <strong>Razão de Ganho</strong>. A Razão de Ganho leva em consideração não apenas o Ganho de Informação proporcionado por uma divisão baseada em um atributo, mas também a Entropia do próprio atributo, ou seja, <strong>a quantidade de informação necessária para identificar o valor de um atributo para uma instância aleatória.</strong> Dessa forma, atributos com muitos valores possíveis são penalizados, tornando o algoritmo menos propenso a escolhê-los para divisões.</p><p>Outras melhorias que podemos citar é a possibilidade de lidar com atributos contínuos e dados faltantes. Além disso, é possível simplificar a Árvore de Decisão para evitar sobreajuste aos dados de treinamento por meio da fase de pós-poda.</p><h3>Implementando uma Árvore de Decisão de Classificação “from scratch”.</h3><p>A construção da árvore começa com a criação de um nó raiz, que é criado a partir do conjunto de dados de treinamento completo. A partir daí, o conjunto de dados é dividido recursivamente, baseado nos recursos que minimizam a impureza, até que a profundidade máxima seja atingida ou até que a impureza não possa mais ser reduzida.</p><h3>A Classe Nó</h3><p>A estrutura fundamental de uma Árvore de Decisão é o nó, que é representado pela classe <strong><em>Node</em></strong>. Cada nó contém informações sobre um ponto de divisão baseado em um recurso (<strong><em>feature_index</em></strong>) e um limiar (<strong><em>threshold</em></strong>). Os nós também contêm referências para seus nós filhos - <strong><em>left </em></strong>e <strong><em>right</em></strong>, que são definidos com base no ponto de divisão.</p><pre>class Node:<br>  def __init__(self, predicted_class):<br>          self.predicted_class = predicted_class<br>          self.feature_index = 0<br>          self.threshold = 0<br>          self.left = None<br>          self.right = None</pre><p>O nó esquerdo (<strong><em>left</em></strong>) e direito (<strong><em>right</em></strong>) são inicializados com valor <strong><em>None. </em></strong>Em seguida, temos uma série de funções auxiliares que verificam o estado do nó (<strong><em>is_leaf</em></strong>, <strong><em>has_left</em></strong>, <strong><em>has_right</em></strong>, <strong><em>has_both_children</em></strong>) e manipulam os nós filhos (<strong><em>get_leaves</em></strong>, <strong><em>make_leaf</em></strong>, <strong><em>restore</em></strong>). Elas serão úteis para a construção e poda da árvore.</p><h3>A classe DecisionTree</h3><p>A função <strong><em>__init__ </em></strong>para a classe <strong><em>DecisionTree</em></strong> define as variáveis iniciais que controlam a construção da árvore. Definimos <strong><em>max_depth </em></strong>para controlar a profundidade máxima da árvore. Isso está intimamente ligado com a complexidade do modelo e um possível <strong>overfitting</strong>.</p><pre>class DecisionTree:<br>    def __init__(self, max_depth=None):<br>        self.max_depth = max_depth</pre><h4>Função fit</h4><p>A função <strong><em>fit </em></strong>inicia a construção da Árvore de Decisão. Primeiro, armazena o número de classes e características do conjunto de treinamento. Em seguida, chama a função recursiva <strong><em>_grow_tree </em></strong>para construir a árvore.</p><pre>def fit(self, X, y):<br>    self.n_classes_ = len(set(y))<br>    self.n_features_ = X.shape[1]<br>    self.tree_ = self._grow_tree(X, y)</pre><h4>Função _grow_tree</h4><p>A função <strong><em>_grow_tree</em></strong> é uma função recursiva que constrói a árvore. Ela verifica a condição de parada (profundidade máxima ou nó puro) e em seguida procura a melhor divisão. Uma vez que a melhor divisão é encontrada, a função chama a si mesma novamente para os subconjuntos da esquerda e da direita até chegarmos a condição de parada.</p><pre>def _grow_tree(self, X, y, depth=0):<br>    num_samples_per_class = [np.sum(y == i) for i in range(self.n_classes_)]<br>    predicted_class = np.argmax(num_samples_per_class)<br>    node = Node(predicted_class=predicted_class)<br>    if depth &lt; self.max_depth:<br>        idx, thr = self._best_split(X, y)<br>        if idx is not None:<br>            indices_left = X[:, idx] &lt; thr<br>            X_left, y_left = X[indices_left], y[indices_left]<br>            X_right, y_right = X[~indices_left], y[~indices_left]<br>            node.feature_index = idx<br>            node.threshold = thr<br>            node.left = self._grow_tree(X_left, y_left, depth + 1)<br>            node.right = self._grow_tree(X_right, y_right, depth + 1)<br>    return node</pre><h4>Função _best_split</h4><p>A função <strong><em>_best_split</em></strong> é o coração do nosso algoritmo, encarregada de escolher a melhor divisão em cada nó da árvore com base na R<strong>azão de Ganho</strong>. Ela primeiro avalia todos os recursos disponíveis em nossos dados, ordenando as amostras por valor de atributo e rótulo de classe. Em seguida, para cada valor de atributo, atualiza as contagens de classe em cada lado da divisão proposta e calcula a Razão de Ganho correspondente.</p><p>Ao longo desse processo, ela evita dividir em valores de atributo idênticos e atualiza a “melhor” divisão sempre que encontra uma que resulta em uma maior Razão de Ganho.</p><pre>def _best_split(self, X, y):<br>        m = y.size<br>        if m &lt;= 1:<br>            return None, None<br><br>        num_parent = [np.sum(y == c) for c in range(self.n_classes_)]<br>        best_gain = 0.0<br>        best_idx, best_thr = None, None<br><br>        for idx in range(self.n_features_):<br>            thresholds, classes = zip(*sorted(zip(X[:, idx], y)))<br>            num_left = [0] * self.n_classes_<br>            num_right = num_parent.copy()<br>            split_entropy = self._calculate_split_entropy(X[:, idx])<br>            <br>            for i in range(1, m):<br>                c = classes[i - 1]<br>                num_left[c] += 1<br>                num_right[c] -= 1<br>                gini_left = 1.0 - sum((num_left[x] / i) ** 2 for x in range(self.n_classes_))<br>                gini_right = 1.0 - sum((num_right[x] / (m - i)) ** 2 for x in range(self.n_classes_))<br>                gini = (i * gini_left + (m - i) * gini_right) / m<br>                <br>                if thresholds[i] == thresholds[i - 1]:<br>                    continue<br>                <br>                gain = 1.0 - gini<br>                gain_ratio = gain / split_entropy<br><br>                if gain_ratio &gt; best_gain:<br>                    best_gain = gain_ratio<br>                    best_idx = idx<br>                    best_thr = (thresholds[i] + thresholds[i - 1]) / 2<br><br>        return best_idx, best_thr</pre><h4>Função _calculate_split_entropy</h4><p>A função <strong><em>_calculate_split_entropy</em></strong> tem o objetivo de calcular a entropia, ou seja, uma medida da impureza ou incerteza, para um conjunto de valores de atributos.</p><pre>def _calculate_split_entropy(self, feature_values):<br>        _, counts = np.unique(feature_values, return_counts=True)<br>        probabilities = counts / np.sum(counts)<br>        entropy = -np.sum(probabilities * np.log2(probabilities))<br>        return entropy</pre><h4>Função predict</h4><p>A função <strong><em>predict </em></strong>é usada para fazer previsões em novos dados após a árvore ter sido construída. Ela mapeia cada exemplo do conjunto de dados de entrada para um nó folha por meio da função <strong><em>_predict </em></strong>e retorna as classes de predição.</p><pre>def predict(self, X):<br>    return [self._predict(inputs) for inputs in X]</pre><h4>Função _predict</h4><p>A função <strong><em>_predict </em></strong>é uma função auxiliar recursiva usada para percorrer a Árvore de Decisão. Começando pelo nó raiz, ela verifica o valor da característica no nó atual e se move para a esquerda ou para a direita dependendo do valor da característica. Quando atinge um nó folha, retorna a classe de predição.</p><p>Vale resssaltar que em Python é comum usar um underscore (_) antes do nome de uma função para indicar que ela é de uso interno e não deve ser chamada diretamente pelo usuário. Portanto, <strong><em>_predict </em></strong>é uma função de uso interno, enquanto <strong><em>predict </em></strong>é a função de interface que o usuário chamará para fazer previsões.</p><pre>def _predict(self, inputs):<br>    node = self.tree_<br>    while node.left:<br>        if inputs[node.feature_index] &lt; node.threshold:<br>            node = node.left<br>        else:<br>            node = node.right<br>    return node.predicted_class</pre><h4>Função prune</h4><p>A função <strong><em>prune</em></strong> é a função que o usuário chama para iniciar o processo de poda. Ela recebe como entrada um conjunto de dados de teste X_test, as classes correspondentes y_test e depois chama outro método interno para de fato realizar a poda.</p><pre>def prune(self, X_test, y_test):<br>        self.tree_ = self._prune(self.tree_, X_test, y_test)</pre><h4>Função _prune</h4><p>A função <strong><em>_prune </em></strong>é onde a poda real ocorre. Esta é uma função recursiva que percorre a árvore de baixo para cima. Para cada nó que possui os dois filhos (left e right), primeiro chama a si mesma em cada filho. Depois disso é verificado se a remoção deste nó melhoraria a precisão no conjunto de teste. Isso é feito transformando o nó em uma folha, fazendo previsões para o conjunto de teste e calculando a precisão dessas previsões usando a função <strong><em>calculate_accuracy</em></strong>. Se a precisão melhorar (ou permanecer a mesma) o nó continua sendo folha. Caso contrário, os filhos do nó são restaurados. <strong>Lembre-se do motivo de eu ter usado essa função com o “_”, ela não está disponível para uso do usuário.</strong></p><pre>def _prune(self, node, X_test, y_test):<br>        if node.is_leaf():<br>            return node<br>        if node.has_left():<br>            node.left = self._prune(node.left, X_test, y_test)<br>        if node.has_right():<br>            node.right = self._prune(node.right, X_test, y_test)<br>        if node.has_both_children():<br>            leaves = node.get_leaves()<br>            original_accuracy = self.calculate_accuracy(y_test, self.predict(X_test))<br>            node.make_leaf()<br>            new_accuracy = self.calculate_accuracy(y_test, self.predict(X_test))<br>            if new_accuracy &gt;= original_accuracy:<br>                return node<br>            node.restore(leaves)<br>        return node</pre><h4>Função calculate_accuracy</h4><p>A função <strong><em>calculate_accuracy </em></strong>é uma função auxiliar que calcula a acurácia de um conjunto de previsões. Ela recebe como entrada o vetor de classes verdadeiras y_true e o vetor de previsões y_pred, e retorna a fração de previsões que são iguais às classes verdadeiras. Esta é uma métrica comum para avaliar o desempenho de um modelo de classificação.</p><pre>def _calculate_split_entropy(self, X):<br>        _, counts = np.unique(X, return_counts=True)<br>        probabilities = counts / counts.sum()<br>        entropy = sum(-p * np.log2(p) for p in probabilities)<br>        return entropy</pre><h3>Conclusão</h3><p>Neste artigo, foquei na compreensão e implementação de Árvores de Decisão para <strong>classificação</strong>. Tentei deixar claro como Árvores de Decisão usam um conjunto de regras de decisão, representadas como uma estrutura de árvore, para classificar entradas em categorias distintas.</p><p>Embora as Árvores de Decisão sejam excelentes ferramentas para tarefas de classificação, é importante lembrar que elas também podem ser adaptadas para resolver problemas de regressão, onde o objetivo é prever um valor contínuo.</p><p><strong>E é exatamente isso que faremos na Parte 2 deste artigo. Vamos explorar as Árvores de Decisão para regressão, aprender como elas diferem das árvores usadas para classificação e como podemos construí-las usando Python.</strong></p><p>Até lá, espero que este artigo tenha sido útil para você. Continue aprendendo, não desista nunca e até a próxima!</p><p><strong>Dá uma olhada no meu </strong><a href="https://github.com/pedrocrp/pedrocrp"><strong>Github</strong></a><strong> e no meu </strong><a href="https://www.linkedin.com/in/pedrocesarrp/"><strong>Linkedin</strong></a><strong>!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ee3d251a616" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lei dos Grandes Números: Teoria e Implementação em Python]]></title>
            <link>https://medium.com/@pedrorp/lei-dos-grandes-n%C3%BAmeros-teoria-e-implementa%C3%A7%C3%A3o-em-python-d84b11482197?source=rss-4c0cffa176c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/d84b11482197</guid>
            <category><![CDATA[probability]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[statistics]]></category>
            <dc:creator><![CDATA[Pedro César Ribeiro Passos]]></dc:creator>
            <pubDate>Wed, 28 Jun 2023 03:25:53 GMT</pubDate>
            <atom:updated>2023-06-28T18:31:54.555Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/623/1*0QfY6uPqPnyjN3dpo0js0w.png" /></figure><h3>Introdução à Lei dos Grandes Números</h3><p>A Lei dos Grandes Números é um princípio fundamental da teoria da probabilidade e estatística que descreve o resultado de realizar o mesmo experimento um grande número de vezes. Segundo este teorema, a média dos resultados obtidos a partir de um grande número de tentativas deve se aproximar do valor esperado e tende a se tornar mais próximo quanto mais tentativas são realizadas. A média é definida como a soma de todos os resultados dividida pelo número de tentativas.</p><p>Por exemplo, imagine que você está jogando uma moeda justa várias vezes. Para cada jogada a probabilidade de dar “cara” é 0,5 . Se você jogar a moeda 10 vezes, pode-se obter 3 “caras” e 7 “coroas”. A média é 0,3 (3/10). Se jogar 100 vezes, pode obter 47 “caras”, com uma média de 0,47 (47/100). Se jogar 1000 vezes, pode obter 509 “caras”, com uma média de 0,509 (509/1000). À medida que o número de jogadas aumenta, a média de “caras” tende a se aproximar do valor esperado de 0,5.</p><p>Há duas versões principais deste teorema: a <strong>Lei Fraca dos Grandes Números</strong> e a <strong>Lei Forte dos Grandes Números</strong>.</p><h3>Lei Fraca dos Grandes Números</h3><p>A Lei Fraca dos Grandes Números fornece uma garantia de que, sob certas condições, a média de uma sequência de variáveis aleatórias independentes e identicamente distribuídas (i.i.d) <strong>converge em probabilidade</strong> para o valor esperado. Ou seja, conforme você realiza mais experimentos, é provável que a média de todos os resultados que você observou fique mais próxima do valor médio esperado.</p><h4>Independência e Identidade de Distribuição</h4><p>Um dos pressupostos importantes é que as variáveis aleatórias são independentes e identicamente distribuídas (i.i.d). A independência refere-se ao fato de que o resultado de um experimento não influencia o resultado de outro. <strong>A identidade de distribuição significa que todas as variáveis aleatórias na sequência são retiradas da mesma distribuição de probabilidade</strong>.</p><p>Por exemplo, em uma série de lançamentos de moeda, cada lançamento é independente dos outros e todos têm a mesma probabilidade de resultar em “cara” ou “coroa”. Portanto, esses lançamentos de moedas são i.i.d.</p><h4>Convergência em Probabilidade</h4><p>A <strong>convergência em probabilidade</strong> refere-se à diferença entre a média amostral e o valor esperado ao se tornar cada vez menos provável de exceder qualquer valor positivo pequeno à medida que o tamanho da amostra aumenta.</p><p>Formalmente, isso é expresso da seguinte maneira:</p><ul><li>Se <em>X1, X2, X3, …, Xn</em> são variáveis aleatórias i.i.d. cada uma com média <strong>μ</strong></li><li>Se Sn é a soma de <em>X1</em> a <em>Xn</em></li></ul><p><strong>Então para qualquer número positivo<em> ε</em>, o limite quando n tende ao infinito de <em>P(|Sn/n — μ| ≥ ε)</em> é igual a zero.</strong></p><h3>Lei Forte dos Grandes Números</h3><p>A Lei Forte dos Grandes Números é uma extensão robusta do Teorema dos Grandes Números, que, assim como a Lei Fraca dos Grandes Números, estabelece que a média de uma sequência de variáveis aleatórias independentes e identicamente distribuídas (i.i.d.) converge para o valor esperado. No entanto, a Lei vai além,<strong> afirmando que essa convergência é “quase certa”</strong>. Em termos simples, <strong>à medida que o número de observações se aproxima do infinito, a probabilidade de que a média das observações seja igual ao valor esperado é de fato igual a um</strong>.</p><p>Para reiterar, a Lei Forte dos Grandes Números engloba a Lei Fraca dos Grandes Números quando as condições para a aplicação da Lei Forte são atendidas, isso garante tanto a convergência “quase certa” (um termo associado à Lei Forte) quanto a convergência “em probabilidade” (associada à Lei Fraca).</p><p><strong>No entanto, a recíproca não é verdadeira</strong>: existem situações em que a Lei Fraca se aplica (ou seja, a convergência ocorre em probabilidade), mas a Lei Forte não, significando que a convergência “quase certa” não é garantida nessas situações.</p><p>Um exemplo seriam as distribuições de cauda pesada. Em uma distribuição de cauda pesada, a probabilidade de observar valores extremos não decai tão rapidamente quanto em uma distribuição de cauda leve.</p><h3>A Falácia do Apostador</h3><p>Aplicando o conceito da Lei dos Grandes Números aos jogos de cassino, embora “a casa” possa ter perdas imediatas, com um número grande de jogos seus ganhos tendem para uma porcentagem previsível, superando sequências de vitórias dos jogadores. Isso destaca o erro da “falácia do apostador”, que é a crença equivocada de que resultados passados podem influenciar eventos futuros em jogos de azar.</p><p>Então, se uma moeda cai 10 vezes “coroa”, a próxima cairá cara, certo? Não necessariamente! Na realidade a probabilidade de tirar “cara” ou “coroa” permanece a mesma, 50%.</p><p>Para evitar cair na falácia do apostador, é crucial compreender e aceitar que eventos aleatórios são independentes e que o resultado anterior não tem impacto nos resultados futuros.</p><h3>Implementação em Python da Lei dos Grandes Números</h3><p>A função <em>LLN </em>é definida para simular jogos de cara ou coroa, demonstrando assim a Lei dos Grandes Números. Ela tem dois parâmetros: <em>interactions</em>, que define o número de jogos que queremos simular, e <em>fair</em>, um parâmetro booleano que indica se a moeda é justa ou não.</p><p>Dentro da função, primeiramente configuramos a semente do gerador de números aleatórios para garantir que os resultados sejam reproduzíveis. Em seguida, verificamos o parâmetro <em>fair</em>. Se a moeda é justa, definimos <em>p = [0.5, 0,5]</em> e <em>expected_value = 0.5</em>, representando uma probabilidade igual para cara e coroa e um valor esperado de 0.5. Se a moeda não é justa, definimos <em>p = [0.3, 0.7]</em> e <em>expected_value = 0.7</em>, indicando que a probabilidade de tirar coroa é maior.</p><p>A próxima parte do código é um loop que itera sobre o número de interações. Para cada interação, geramos um número aleatório de caras e coroas de acordo com a probabilidade definida em <em>p</em>, calculamos a média dos resultados e adicionamos essa média à lista <em>mean_outcomes_all</em>.</p><p>Após o fim do loop, criamos um gráfico que mostra a média dos resultados em função do número de interações. A linha vermelha tracejada representa o valor esperado.</p><pre>import numpy as np<br>import matplotlib.pyplot as plt<br><br>def LLN(interactions = 1000, fair=True):<br>    &quot;&quot;&quot;<br>    Demonstrates the Law of Large Numbers by simulating coin tosses.<br><br>    Args:<br>    interactions (int): Number of games or iterations to simulate.<br>    fair (bool): Indicate whether the coin is fair or not.<br>    &quot;&quot;&quot;<br><br>    np.random.seed(42)<br>    n_trials = 10<br>    <br>    if fair:<br>        p = [0.5, 0.5]<br>        expected_value = 0.5<br>    else:<br>        p = [0.3, 0.7]<br>        expected_value = 0.7<br><br>    mean_outcomes_all = []<br><br>    for n in range(1, interactions + 1):<br>        print(n)<br>        trials = np.random.choice([0, 1], size=(n_trials, n), p=p)<br>        mean_outcomes = trials.mean(axis=1).mean()<br>        mean_outcomes_all.append(mean_outcomes)<br><br>    plt.figure(figsize=(10, 6))<br>    plt.plot(list(range(1, interactions + 1)), mean_outcomes_all, &#39;X&#39;, markersize=5)<br>    plt.xlabel(&#39;Number of Experiments&#39;, fontsize=13)<br>    plt.ylabel(&#39;Average of Outcomes&#39;, fontsize=13)<br>    plt.title(&#39;Average of Outcomes vs Number of Experiments&#39;, fontsize=15)<br>    plt.axhline(expected_value, color=&#39;red&#39;, linestyle=&#39;dashed&#39;, linewidth=2, label=&#39;Expectation&#39;)<br>    plt.legend()<br>    plt.savefig(&#39;distribution_graph&#39;)</pre><p>Abaixo mostro os resultados para diferenciar uma situação em que a moeda lançada é justa e outra em que ela não é justa. Perceba como com o aumento da quantidade de experimentos a distribuição dos resultados se concentra próximo ao valor esperado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*l5apYxZBLbyzt4zjQG9OAg.png" /><figcaption>Experimento com uma moeda “não justa”.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*BkH8uwRvcjxUmDRWG88OTQ.png" /><figcaption>Experimento com uma moeda “justa”.</figcaption></figure><h3>Conclusão</h3><p>A Lei dos Grandes Números é um pilar fundamental na teoria das probabilidades e fornece a base para várias técnicas estatísticas. Através das duas principais versões desta lei, a Lei Fraca e a Lei Forte dos Grandes Números, conseguimos entender como as médias de amostras de uma distribuição se comportam à medida que o tamanho da amostra aumenta.</p><p>Espero que esse artigo tenha sido útil para você, até mais!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d84b11482197" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Guia de Codificadores de Atributos Categóricos em Machine Learning]]></title>
            <link>https://medium.com/@pedrorp/guia-de-codificadores-de-atributos-categ%C3%B3ricos-em-machine-learning-60a9f22c9a3b?source=rss-4c0cffa176c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/60a9f22c9a3b</guid>
            <category><![CDATA[ciencia-de-dados]]></category>
            <category><![CDATA[aprendizado-de-maquina]]></category>
            <category><![CDATA[machinelearningalgorithms]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Pedro César Ribeiro Passos]]></dc:creator>
            <pubDate>Tue, 13 Jun 2023 04:46:54 GMT</pubDate>
            <atom:updated>2023-06-13T04:46:54.807Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SqRjLRXF8s7OlSPhRv0Viw.png" /></figure><p>O mundo dos dados é diverso, e um dos desafios mais comuns ao trabalhar com dados é lidar com variáveis categóricas. Essas são variáveis que podem ser divididas em várias categorias. Exemplos incluem cores, nomes de cidades, tipos de veículos, entre outros.</p><p>Os modelos de Machine Learning, em sua maioria, esperam receber dados numéricos. Para usar essas variáveis categóricas em nossos modelos, precisamos convertê-las em números de alguma forma. É aqui que entram os Codificadores de Características.</p><p>Os Codificadores de Atributos (ou Feature Encoders) são métodos usados para transformar atributos categóricos em representações numéricas que os algoritmos de Machine Learning conseguem processar. Existem vários métodos de codificação disponíveis, e a escolha do método depende do tipo de variável categórica e do algoritmo que você planeja usar.</p><p>Esse artigo mostrará os principais Encoders e exemplos de como usá-los. Se quiser ver o notebook usado para o estudo de uso de cada um deles, por favor olhe meu <a href="https://github.com/pedrocrp/data_projects/tree/main/feature_encoders_tutorial">GitHub</a>!</p><h3>Quando usar os Features Encoders</h3><p>É importante lembrar que a codificação deve ser feita <strong>após a divisão dos dados em conjuntos de treinamento e teste</strong>. Isso evita o vazamento de dados, que ocorre quando informações fora do conjunto de treinamento são usadas para criar o modelo. A divisão treino/teste deve sempre ser respeitada, e <strong>apenas os dados de treinamento devem ser usados para ajustar (fit) o codificador</strong>.</p><h3>Diferentes tipos de codificadores</h3><p>Existem vários métodos de codificação e cada um tem suas próprias características, vantagens e desvantagens. Vamos falar sobre alguns dos mais comuns.</p><h3>Codificação One-Hot</h3><p>Um dos métodos mais comuns e diretos para lidar com variáveis categóricas é a codificação One-Hot. Essa técnica transforma cada categoria de uma variável em uma nova coluna binária (0 ou 1). Cada uma dessas novas colunas indica a presença (1) ou ausência (0) da categoria correspondente na instância de dados original.</p><p>Por exemplo, se tivermos uma variável ‘animal’ com as categorias ‘cachorro’, ‘gato’ e ‘pássaro’, a codificação one-hot transformaria essa única coluna em três colunas: ‘animal_cachorro’, ‘animal_gato’, e ‘animal_pássaro’. Cada instância de dados teria um ‘1’ em uma dessas colunas e ‘0’ nas outras, dependendo da categoria original.</p><pre>from category_encoders import OneHotEncoder<br>from sklearn.model_selection import train_test_split<br><br>df = pd.DataFrame({<br>    &#39;animal&#39;: [&#39;cachorro&#39;, &#39;elefante&#39;, &#39;galinha&#39;, &#39;leao&#39;, &#39;ser humano&#39;, &#39;cachorro&#39;, &#39;gato&#39;, &#39;ser humano&#39;, &#39;elefante&#39;, &#39;pardal&#39;, &#39;macaco&#39;, &#39;cachorro&#39;],<br>    &#39;locomocao&#39; : [&#39;quadrupede&#39;, &#39;quadrupede&#39;,&#39;bipede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;,  &#39;quadrupede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;],<br>    &#39;target&#39;: [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0]<br>})<br><br>X_train, X_test, y_train, y_test = train_test_split(df.drop(&#39;target&#39;, axis=1), df[&#39;target&#39;], test_size=0.2, random_state=42)<br><br>encoder = OneHotEncoder(cols=[&#39;animal&#39;, &#39;locomocao&#39;])<br><br># Treino<br>encoder.fit(X_train)<br>X_train_encoded = encoder.transform(X_train)<br><br># Teste<br>X_test_encoded = encoder.transform(X_test)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/717/1*srl-U-kGyOLS4GSd1hEkOQ.png" /><figcaption>Resultado do X_train depois do transform com o One-Hot Encoder</figcaption></figure><p>Embora a codificação One-Hot seja uma técnica eficaz e amplamente utilizada, ela pode aumentar a dimensionalidade do conjunto de dados se a variável categórica tiver muitas categorias únicas. Isso pode levar a um aumento no tempo de computação e na memória necessária, bem como possivelmente reduzir o desempenho do modelo devido à “maldição da dimensionalidade”.</p><p>Para um dado tamanho de amostras, existe um número máximo de características a partir do qual o desempenho do classificador irá degradar, ao invés de melhorar. Para saber mais sobre isso, sugiro estudar sobre o trade-off em modelos de ML. Aqui está um artigo escrito por mim sobre o assunto: <a href="https://medium.com/@pedrorp/balancing-trade-offs-in-machine-learning-algorithms-a-contextual-approach-7a4c382846a3.">https://medium.com/@pedrorp/balancing-trade-offs-in-machine-learning-algorithms-a-contextual-approach-7a4c382846a3.</a></p><p>Outro ponto a se destacar, é que a multicolinearidade pode ser um problema ao usar a codificação One-Hot, já que as variáveis codificadas estão altamente correlacionadas. Isso pode ser evitado ao remover uma das colunas codificadas (também conhecida como “dummy variable trap”).</p><h3>Codificação de Rótulo (Label Encoding)</h3><p>A Codificação de Rótulo é uma técnica de codificação na qual cada categoria única de uma variável categórica é atribuída a um número inteiro único. Por exemplo, se tivermos uma variável ‘animal’ com as categorias ‘cachorro’, ‘gato’ e ‘pássaro’, a codificação de rótulo pode transformar estas em ‘0’, ‘1’ e ‘2’, respectivamente.</p><pre>from category_encoders import OrdinalEncoder<br>from sklearn.model_selection import train_test_split<br><br>df = pd.DataFrame({<br>    &#39;animal&#39;: [&#39;cachorro&#39;, &#39;elefante&#39;, &#39;galinha&#39;, &#39;leao&#39;, &#39;ser humano&#39;, &#39;cachorro&#39;, &#39;gato&#39;, &#39;ser humano&#39;, &#39;elefante&#39;, &#39;pardal&#39;, &#39;macaco&#39;, &#39;cachorro&#39;],<br>    &#39;locomocao&#39; : [&#39;quadrupede&#39;, &#39;quadrupede&#39;,&#39;bipede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;,  &#39;quadrupede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;],<br>    &#39;target&#39;: [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0]<br>})<br><br>X_train, X_test, y_train, y_test = train_test_split(df.drop(&#39;target&#39;, axis=1), df[&#39;target&#39;], test_size=0.2, random_state=42)<br><br>encoder = OrdinalEncoder(cols=[&#39;animal&#39;, &#39;locomocao&#39;])<br><br># Treino<br>encoder.fit(X_train)<br>X_train_encoded = encoder.transform(X_train)<br><br># Teste<br>X_test_encoded = encoder.transform(X_test)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/198/1*ih8ADlHhCacWMm3Zvs9LWg.png" /><figcaption>Resultado do X_train depois do transform utilizando LaberEncoder</figcaption></figure><p>Vale notar que a Codificação de Rótulo cria uma suposição implícita de que as categorias têm uma ordem ou hierarquia, que pode ou não existir. Nesse sentido, esta é melhor utilizada com variáveis categóricas ordinais, onde existe uma ordem intrínseca entre as categorias (“pequeno”, “médio” e “grande”).</p><p>Para variáveis categóricas nominais, onde não há ordem ou hierarquia, outras técnicas de codificação podem ser mais apropriadas.</p><h3>Codificação Binária</h3><p>A Codificação Binária é uma técnica de processamento de dados categóricos usada quando o número de categorias é bastante alto. Isso pode ser útil para garantir que a dimensionalidade do conjunto de dados não se torne muito grande ao codificar as categorias.</p><p>Com a Codificação Binária, primeiramente, as categorias são codificadas como inteiros ordinais. Depois, esses inteiros são convertidos em binário. A vantagem disso é que a codificação binária permite representar muitas categorias com relativamente poucas colunas novas.</p><pre>from category_encoders import BinaryEncoder<br>from sklearn.model_selection import train_test_split<br><br>df = pd.DataFrame({<br>    &#39;animal&#39;: [&#39;cachorro&#39;, &#39;elefante&#39;, &#39;galinha&#39;, &#39;leao&#39;, &#39;ser humano&#39;, &#39;cachorro&#39;, &#39;gato&#39;, &#39;ser humano&#39;, &#39;elefante&#39;, &#39;pardal&#39;, &#39;macaco&#39;, &#39;cachorro&#39;],<br>    &#39;locomocao&#39; : [&#39;quadrupede&#39;, &#39;quadrupede&#39;,&#39;bipede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;,  &#39;quadrupede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;],<br>    &#39;target&#39;: [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0]<br>})<br><br>X_train, X_test, y_train, y_test = train_test_split(df.drop(&#39;target&#39;, axis=1), df[&#39;target&#39;], test_size=0.2, random_state=42)<br><br>encoder = BinaryEncoder(cols=[&#39;animal&#39;, &#39;locomocao&#39;])<br><br># Treino<br>encoder.fit(X_train)<br>X_train_encoded = encoder.transform(X_train)<br><br># Teste<br>X_test_encoded = encoder.transform(X_test)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/482/1*mnQck0ibZg5ufculQhSOqA.png" /><figcaption>Resultado do X_train depois do transform utilizando BinaryEncoder</figcaption></figure><p>No exemplo acima, as colunas ‘animal’ e ‘locomocao’ do DataFrame são transformadas em colunas binárias. O codificador é treinado apenas com os dados de treino para evitar qualquer vazamento de informação dos dados de teste. Depois, usamos o codificador treinado para transformar nossos conjuntos de treino e teste.</p><p>A codificação binária pode ser útil quando temos muitas categorias a serem codificadas, mas assim como todas as técnicas, também tem suas limitações. Por exemplo, pode não ser a melhor escolha quando as categorias têm valores importantes que seriam perdidos na conversão para binário. Além disso, essa abordagem aumenta a dimensionalidade dos dados, o que pode ser problemático para alguns modelos de Machine Learning.</p><h3>Codificação Helmert</h3><p>A Codificação Helmert é um método de codificação de variáveis categóricas que pode ser útil para explorar comparações entre cada nível de uma categoria e a média dos níveis subsequentes.</p><p>Este tipo de codificação pode ser útil em análises estatísticas onde estamos interessados em efeitos de contraste, isto é, diferenças entre diferentes níveis de uma variável categórica.</p><p>Na Codificação Helmert, a primeira categoria é codificada como -1, a segunda categoria como 1, e todas as outras como 0. Para a próxima coluna, a segunda categoria é codificada como -1, as duas próximas categorias como 1, e todas as outras como 0. Este processo continua para todas as categorias.</p><pre>from category_encoders import HelmertEncoder<br>from sklearn.model_selection import train_test_split<br><br>df = pd.DataFrame({<br>    &#39;animal&#39;: [&#39;cachorro&#39;, &#39;elefante&#39;, &#39;galinha&#39;, &#39;leao&#39;, &#39;ser humano&#39;, &#39;cachorro&#39;, &#39;gato&#39;, &#39;ser humano&#39;, &#39;elefante&#39;, &#39;pardal&#39;, &#39;macaco&#39;, &#39;cachorro&#39;],<br>    &#39;locomocao&#39; : [&#39;quadrupede&#39;, &#39;quadrupede&#39;,&#39;bipede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;,  &#39;quadrupede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;],<br>    &#39;target&#39;: [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0]<br>})<br><br>X_train, X_test, y_train, y_test = train_test_split(df.drop(&#39;target&#39;, axis=1), df[&#39;target&#39;], test_size=0.2, random_state=42)<br><br>encoder = HelmertEncoder(cols=[&#39;animal&#39;, &#39;locomocao&#39;])<br><br># Treino<br>encoder.fit(X_train)<br>X_train_encoded = encoder.transform(X_train)<br><br># Teste<br>X_test_encoded = encoder.transform(X_test)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/609/1*bM_9dQZLSONv3ojrG8MfWg.png" /><figcaption>Resultado do X_train depois do transform utilizando HelmertEncoder</figcaption></figure><p>Embora a codificação Helmert possa ser útil em certas situações, é importante notar que ela é menos comum do que outras técnicas de codificação, como One-Hot ou Codificação Binária. A interpretação dos resultados após a codificação Helmert também pode ser mais complexa, uma vez que os resultados são em termos de diferenças entre as categorias e a média das categorias subsequentes. Portanto, este método de codificação é mais comumente usado em análises estatísticas avançadas.</p><h3>Codificação Hashing</h3><p>A Codificação Hashing, também conhecida como “Hashing Trick”, é um método eficiente para codificar variáveis categóricas, especialmente quando se lida com um grande número de categorias distintas. Ela usa o hash dos valores das categorias para representá-los numericamente.</p><p>A ideia por trás dessa técnica é converter as categorias em índices de um vetor, usando uma função hash. O tamanho do vetor, ou seja, a quantidade de “buckets”, é um parâmetro que deve ser definido. Quando uma colisão de hash ocorre (dois valores diferentes mapeados para a mesma posição), os valores são adicionados em vez de substituídos na posição do vetor.</p><p>Uma das principais vantagens da Codificação de Hashing é que ela não aumenta a dimensionalidade dos dados e pode lidar com novas categorias durante a fase de teste, pois utiliza a função de hash para codificar as categorias e não precisa de informações sobre os dados de treino.</p><pre>from category_encoders import HashingEncoder<br>from sklearn.model_selection import train_test_split<br><br>df = pd.DataFrame({<br>    &#39;animal&#39;: [&#39;cachorro&#39;, &#39;elefante&#39;, &#39;galinha&#39;, &#39;leao&#39;, &#39;ser humano&#39;, &#39;cachorro&#39;, &#39;gato&#39;, &#39;ser humano&#39;, &#39;elefante&#39;, &#39;pardal&#39;, &#39;macaco&#39;, &#39;cachorro&#39;],<br>    &#39;locomocao&#39; : [&#39;quadrupede&#39;, &#39;quadrupede&#39;,&#39;bipede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;,  &#39;quadrupede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;],<br>    &#39;target&#39;: [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0]<br>})<br><br>X_train, X_test, y_train, y_test = train_test_split(df.drop(&#39;target&#39;, axis=1), df[&#39;target&#39;], test_size=0.2, random_state=42)<br><br>encoder = HashingEncoder(cols=[&#39;animal&#39;, &#39;locomocao&#39;], n_components=8)<br><br># Treino<br>encoder.fit(X_train, y_train)<br>X_train_encoded = encoder.transform(X_train)<br><br># Teste<br>X_test_encoded = encoder.transform(X_test)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/449/1*yV9PcPJ0dNXJpq85Lce4XA.png" /><figcaption>Resultado do X_train depois do transform utilizando HashingEncoder</figcaption></figure><p>Deve-se notar que, embora a Codificação de Hashing possa ser eficiente, ela tem a desvantagem de ser irreversível e não intuitiva, uma vez que os valores hash não têm relação intrínseca com as categorias originais. Além disso, a colisão de hash pode ocorrer e resultar em perdas de informação.</p><h3>Codificação de Frequência</h3><p>Como o nome sugere, essa técnica envolve substituir cada categoria pelo número de vezes que ela aparece no conjunto de dados, sua frequência. Este método é especialmente útil quando as frequências de certas categorias têm relação com a variável de resposta. Por exemplo, em um conjunto de dados de compras de supermercado, os produtos que são comprados com frequência (como pão ou leite) podem ter uma maior probabilidade de aparecer no carrinho de um cliente aleatório.</p><pre>from sklearn.model_selection import train_test_split<br><br>df = pd.DataFrame({<br>    &#39;animal&#39;: [&#39;cachorro&#39;, &#39;elefante&#39;, &#39;galinha&#39;, &#39;leao&#39;, &#39;ser humano&#39;, &#39;cachorro&#39;, &#39;gato&#39;, &#39;ser humano&#39;, &#39;elefante&#39;, &#39;pardal&#39;, &#39;macaco&#39;, &#39;cachorro&#39;],<br>    &#39;locomocao&#39; : [&#39;quadrupede&#39;, &#39;quadrupede&#39;,&#39;bipede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;,  &#39;quadrupede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;],<br>    &#39;target&#39;: [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0]<br>})<br><br>X_train, X_test, y_train, y_test = train_test_split(df.drop(&#39;target&#39;, axis=1), df[&#39;target&#39;], test_size=0.2, random_state=42)<br><br>animal_freq = X_train[&#39;animal&#39;].value_counts() / len(X_train)<br>locomocao_freq = X_train[&#39;locomocao&#39;].value_counts() / len(X_train)<br><br>X_train_encoded = X_train.copy()<br>X_train_encoded[&#39;animal&#39;] = X_train[&#39;animal&#39;].map(animal_freq)<br>X_train_encoded[&#39;locomocao&#39;] = X_train[&#39;locomocao&#39;].map(locomocao_freq)<br><br>X_test_encoded = X_test.copy()<br>X_test_encoded[&#39;animal&#39;] = X_test[&#39;animal&#39;].map(animal_freq)<br>X_test_encoded[&#39;locomocao&#39;] = X_test[&#39;locomocao&#39;].map(locomocao_freq)<br><br># Preenche NaNs para categorias não vistas durante o treinamento com uma frequência de 0<br>X_train_encoded.fillna(0, inplace=True)<br>X_test_encoded.fillna(0, inplace=True)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/210/1*Uv9BR1ewuJHxH8VpcUg7RQ.png" /><figcaption>Resultado do X_train depois do transform</figcaption></figure><p>Ao usar a Codificação de Frequência, devemos ter cuidado com categorias raras que podem ter frequências muito baixas. Além disso, duas categorias diferentes com a mesma frequência receberão a mesma codificação, o que pode levar a perda de informações importantes.</p><h3>Codificação de Alvo (Target Encoding)</h3><p>A Codificação de Alvo (também conhecida como Mean Encoding, Likelihood Encoding, entre outros) é uma técnica avançada de processamento de variáveis categóricas. Ela funciona substituindo uma categoria por um número, geralmente a média da variável de resposta para essa categoria.</p><p>Em outras palavras, para cada categoria na variável de características, nós calculamos a média do valor de destino. Então substituímos a categoria pela média calculada. Isso pode ser especialmente útil quando há uma relação entre a categoria e o valor de destino que queremos prever.</p><p>No entanto, esse método tem um grande perigo: se não for feito corretamente, pode resultar em overfitting, porque estamos usando informações do conjunto de treino para codificar as categorias. Portanto, é importante fazer essa codificação dentro do esquema de validação cruzada para evitar qualquer vazamento de dados.</p><pre>from sklearn.model_selection import KFold<br>from category_encoders import TargetEncoder<br><br>df = pd.DataFrame({<br>    &#39;animal&#39;: [&#39;cachorro&#39;, &#39;elefante&#39;, &#39;galinha&#39;, &#39;leao&#39;, &#39;ser humano&#39;, &#39;cachorro&#39;, &#39;gato&#39;, &#39;ser humano&#39;, &#39;elefante&#39;, &#39;pardal&#39;, &#39;macaco&#39;, &#39;cachorro&#39;],<br>    &#39;locomocao&#39; : [&#39;quadrupede&#39;, &#39;quadrupede&#39;,&#39;bipede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;,  &#39;quadrupede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;],<br>    &#39;target&#39;: [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0]<br>})<br><br>kf = KFold(n_splits=5, shuffle=True, random_state=42)<br><br>X = df.drop(&#39;target&#39;, axis=1)<br>y = df[&#39;target&#39;]<br><br>for tr_ind, val_ind in kf.split(X):<br>    X_train, y_train = X.iloc[tr_ind], y.iloc[tr_ind]<br>    X_val, y_val = X.iloc[val_ind], y.iloc[val_ind]<br><br>    encoder = TargetEncoder(cols=[&#39;animal&#39;, &#39;locomocao&#39;])<br>    <br>    # Treino<br>    encoder.fit(X_train, y_train)<br>    X_train_encoded = encoder.transform(X_train)<br>    <br>    # Validação<br>    X_val_encoded = encoder.transform(X_val)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/210/1*1raYGEejK9xKyZzFCpQS-Q.png" /><figcaption>Resultado do X_train depois do transform utilizando TargetEncoder</figcaption></figure><p>Lembre-se de que a Codificação de Alvo deve ser feita com cautela para evitar vazamento de dados. Além disso, como qualquer outra técnica de codificação, ela pode não ser a melhor escolha para todos os conjuntos de dados e tarefas.</p><h3>Codificação de Retorno de Probabilidade (Weight of Evidence Encoding)</h3><p>A Codificação de Retorno de Probabilidade, também conhecida como Weight of Evidence (WoE) Encoding, é outra técnica avançada de codificação de variáveis categóricas. Ela foi desenvolvida principalmente para lidar com problemas de classificação binária. O WoE é uma medida do “peso da evidência” de uma determinada categoria em relação à variável de resposta.</p><p>A Codificação WoE calcula o log da razão entre a probabilidade de sucesso (ou seja, a variável alvo é 1) e a probabilidade de não sucesso (ou seja, a variável alvo é 0) para cada categoria. Isso significa que em vez de codificar as categorias com base apenas na média de destino (como no target encoding), o WoE leva em consideração a distribuição da variável de destino em cada categoria.</p><pre>from sklearn.model_selection import KFold<br>from category_encoders import WOEEncoder<br><br>df = pd.DataFrame({<br>    &#39;animal&#39;: [&#39;cachorro&#39;, &#39;elefante&#39;, &#39;galinha&#39;, &#39;leao&#39;, &#39;ser humano&#39;, &#39;cachorro&#39;, &#39;gato&#39;, &#39;ser humano&#39;, &#39;elefante&#39;, &#39;pardal&#39;, &#39;macaco&#39;, &#39;cachorro&#39;],<br>    &#39;locomocao&#39; : [&#39;quadrupede&#39;, &#39;quadrupede&#39;,&#39;bipede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;,  &#39;quadrupede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;],<br>    &#39;target&#39;: [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0]<br>})<br><br>kf = KFold(n_splits=5, shuffle=True, random_state=42)<br><br>X = df.drop(&#39;target&#39;, axis=1)<br>y = df[&#39;target&#39;]<br><br>for tr_ind, val_ind in kf.split(X):<br>    X_train, y_train = X.iloc[tr_ind], y.iloc[tr_ind]<br>    X_val, y_val = X.iloc[val_ind], y.iloc[val_ind]<br><br>    encoder = WOEEncoder()<br><br>    # Treino<br>    encoder.fit(X_train, y_train)<br>    X_train_encoded = encoder.transform(X_train)<br><br>    # Validação<br>    X_val_encoded = encoder.transform(X_val)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/214/1*4gRZ0O5oDnxzmFzxYXMYKQ.png" /><figcaption>Resultado do X_train depois do transform usando o WOEEncoder</figcaption></figure><p>Como a Codificação de Alvo, a Ccodificação WoE também pode levar ao overfitting se não for feita corretamente. Portanto, é importante fazer essa codificação dentro do esquema de validação cruzada para evitar vazamento de dados. Além disso, é melhor usar essa técnica para problemas de classificação binária, pois o conceito de “sucesso” e “não sucesso” pode não ser claramente definido para problemas de regressão ou classificação multiclasse.</p><p>Perceba a presença de números negativos. Isso ocorre porque a Codificação WoE é calculada como o logaritmo natural da proporção da distribuição de “bons resultados” (y = 1) e “maus resultados” (y = 0) para cada categoria. Se a proporção for inferior a 1 (indicando que há mais resultados “maus” do que “bons” para uma categoria específica), o logaritmo natural desse número será negativo.</p><p>Em outras palavras, um valor WoE negativo sugere que a categoria específica está associada a uma probabilidade maior de resultado “mau” (y = 0), enquanto um valor WoE positivo sugere que a categoria está associada a uma maior probabilidade de resultado “bom” (y = 1).</p><p>No entanto, é importante ressaltar que essas codificações não são literalmente “boas” ou “más”. São apenas rótulos para os dois possíveis resultados em um cenário de classificação binária. Portanto, o que é “bom” ou “ruim” dependerá do problema específico que você está tentando resolver.</p><h3>Codificação com CatBoost</h3><p>A Codificação CatBoost é um método relativamente novo e inovador de lidar com variáveis categóricas. Desenvolvido pelos criadores do algoritmo de aprendizado de máquina CatBoost, essa técnica é diferente das outras de várias maneiras.</p><p>A Codificação CatBoost é chamada assim por causa do algoritmo de aumento de gradiente CatBoost, que pode lidar diretamente com variáveis categóricas. O nome “CatBoost” vem de duas palavras: “Categoria” e “Boosting”. A ideia principal por trás do CatBoost é que ele calcula a média de destino para cada categoria e usa essas informações para codificar as categorias. No entanto, ao contrário do Target Encoding, o CatBoost faz isso de uma maneira que evita o vazamento de dados e o overfitting.</p><p>O CatBoost faz isso usando a chamada “ordem de permutação” para calcular a média de destino. Isso significa que em vez de calcular a média de destino para uma categoria com base em todo o conjunto de treinamento, ele calcula apenas com base nas linhas que vieram antes da linha atual em uma ordem aleatória. Isso ajuda a garantir que a codificação para cada linha seja independente das linhas que vêm depois dela, evitando o vazamento de dados.</p><pre>from category_encoders import CatBoostEncoder<br>from sklearn.model_selection import train_test_split<br><br>df = pd.DataFrame({<br>    &#39;animal&#39;: [&#39;cachorro&#39;, &#39;elefante&#39;, &#39;galinha&#39;, &#39;leao&#39;, &#39;ser humano&#39;, &#39;cachorro&#39;, &#39;gato&#39;, &#39;ser humano&#39;, &#39;elefante&#39;, &#39;pardal&#39;, &#39;macaco&#39;, &#39;cachorro&#39;],<br>    &#39;locomocao&#39; : [&#39;quadrupede&#39;, &#39;quadrupede&#39;,&#39;bipede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;,  &#39;quadrupede&#39;,  &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;quadrupede&#39;, &#39;bipede&#39;, &#39;bipede&#39;, &#39;cachorro&#39;],<br>    &#39;target&#39;: [0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0]<br>})<br><br>X_train, X_test, y_train, y_test = train_test_split(df.drop(&#39;target&#39;, axis=1), df[&#39;target&#39;], test_size=0.2, random_state=42)<br><br>encoder = CatBoostEncoder(cols=[&#39;animal&#39;, &#39;locomocao&#39;])<br><br># Treino<br>encoder.fit(X_train, y_train)<br>X_train_encoded = encoder.transform(X_train)<br><br># Teste<br>X_test_encoded = encoder.transform(X_test)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/209/1*QUjxzyrUlooLcUsRc3zrYQ.png" /><figcaption>Resultado do X_train depois do transform usando o CatBoostEncoder</figcaption></figure><p>A Codificação CatBoost é uma opção poderosa para lidar com variáveis categóricas, especialmente quando se tem muitas categorias ou quando a relação entre as categorias e a variável de destino é complexa. No entanto, pode ser computacionalmente intensiva, especialmente em conjuntos de dados maiores.</p><h3>Conclusão</h3><p>Feature Encoders são uma ferramenta essencial para qualquer Cientista de Dados ou Engenheiro de Machine Learning. Eles fornecem uma maneira de transformar dados categóricos em um formato que os algoritmos de aprendizado de máquina podem entender e usar efetivamente.</p><p>Ao longo deste artigo, exploramos uma variedade de técnicas de codificação e examinamos suas vantagens e desvantagens. Cada técnica tem suas forças e fraquezas, e a escolha do codificador certo depende do contexto e do problema específico que você está tentando resolver.</p><p>Em resumo, a escolha da técnica de codificação não deve ser tomada baseada em tutoriais genéricos feitos por gurus de dados que pouco têm conhecimento sobre.</p><p>Espero que este artigo tenha lhe dado uma compreensão mais clara dos codificadores de recursos e de como você pode usá-los em seu trabalho. Caso queira entrar em contato comigo, não exite em mandar uma mensagem para mim no meu <a href="https://www.linkedin.com/in/pedrocesarrp/">Linkedin</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60a9f22c9a3b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Balancing Trade-offs in Machine Learning Algorithms: A Contextual Approach]]></title>
            <link>https://medium.com/@pedrorp/balancing-trade-offs-in-machine-learning-algorithms-a-contextual-approach-7a4c382846a3?source=rss-4c0cffa176c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a4c382846a3</guid>
            <category><![CDATA[ciencia-de-dados]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[visão-computacional]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Pedro César Ribeiro Passos]]></dc:creator>
            <pubDate>Fri, 26 May 2023 04:04:30 GMT</pubDate>
            <atom:updated>2023-05-26T04:04:30.530Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8bpcMaZEvNBY4byU5QEfBA.png" /></figure><h3>Trade-Offs em Algoritmos de Aprendizado de Máquina: Uma Abordagem Conceitual</h3><p>No contexto de Aprendizado de Máquina, um conceito fundamental que gira em torno da estruturação e implementação de algoritmos é o <em>trade-off</em>. Mas o que exatamente esse conceito significa e como ele impacta o desempenho e a precisão de um modelo de Aprendizado de Máquina? Neste artigo, exploraremos a essência dos <em>trade-offs</em> no Aprendizado de Máquina e como eles podem ser efetivamente gerenciados.</p><h3>O que são Trade-Offs no Aprendizado de Máquina?</h3><p>Um <em>trade-off</em> descreve uma situação na qual você sacrifica uma coisa para alcançar outra. No universo do Aprendizado de Máquina, isso representa a necessidade de encontrar um equilíbrio entre duas características que não podem ser maximizadas simultaneamente. O Aprendizado de Máquina apresenta vários compromissos típicos, os mais importantes são o Viés-Variância e a Precisão-Revocação.</p><h3>O Dilema do Viés-Variância</h3><p>Um dos exemplos mais recorrentes de <em>trade-offs</em> no Aprendizado de Máquina é o de Viés-Variância. Isso ocorre durante a fase de treinamento de um modelo, onde buscamos um equilíbrio entre a complexidade do modelo (viés) e sua generalização (variância).</p><p>Um modelo muito simples (alto viés) pode resultar em subajuste (<em>underfitting</em>) — ele não aprende efetivamente a partir dos dados de treinamento e, consequentemente, tem um desempenho ruim. Por outro lado, um modelo de alta variância é excessivamente complexo e está propenso a superajuste (<em>overfitting</em>) — ele aprende “demais” a partir dos dados de treinamento, incluindo o ruído, e falha ao generalizar bem para novos dados.</p><h4>Compreensão prática de viés e variância</h4><p>Para ilustrar o conceito de viés e variância, vamos usar o exemplo de chutes a gol em um jogo de futebol. Se o jogador chuta consistentemente todas as bolas para a esquerda do gol, isso é análogo a alto viés: o chute do jogador é consistente, mas impreciso, sempre fora do alvo (o gol). No contexto do aprendizado de máquina, um modelo com alto viés ignora os detalhes nos dados de treinamento e simplifica excessivamente o problema, levando a um desempenho ruim tanto nos dados de treinamento quanto nos de teste.</p><p>Agora, considere um jogador que chuta a bola em várias direções, de forma que as bolas estão espalhadas ao redor do gol. Apesar da maioria dos chutes resultarem em gols, a dispersão é grande. Isso se assemelha à alta variância: o jogador é inconstante na direção dos chutes, mesmo que, em média, acerte o alvo. No aprendizado de máquina, um modelo com alta variância é altamente sensível aos dados de treinamento e pode capturar ruídos aleatórios nos dados, resultando em superajuste (<em>overfitting</em>). Ele se sai bem nos dados de treinamento, mas falha ao encontrar novos dados ou dados não vistos anteriormente.</p><p>Nem alto viés nem alta variância são ideais em modelos de aprendizado de máquina, sublinhando a importância de equilibrar essas duas forças para garantir que o modelo seja tanto confiável quanto preciso.</p><h4>Modificando a variância e o viés</h4><p>Aumentar o viés implica em simplificar o modelo. Isso pode ser realizado reduzindo o número de características (<em>features</em>) que o modelo utiliza. Por exemplo, você pode decidir selecionar um subconjunto das características disponíveis ou, até mesmo, optar por um modelo mais simples. Como resultado, ele pode não captar toda a complexidade dos dados, levando a erros sistemáticos. Em outras palavras, o modelo é consistentemente “impreciso”.</p><p>Para aumentar a variância, devemos tornar o modelo mais complexo. Isso pode ser feito adicionando mais características para o modelo considerar, o que permite que o modelo aprenda interações mais complexas entre as características. Alternativamente, podemos escolher um modelo mais complexo, como uma rede neural profunda ou um conjunto de modelos, como Random Forest. Essas abordagens tendem a aumentar a variância porque o modelo está tentando capturar mais informação e, portanto, pode acabar “aprendendo demais” dos dados de treinamento. O modelo aprende tanto os padrões úteis quanto o ruído presente nos dados, o que pode levar a um desempenho fraco quando o modelo é apresentado a novos dados.</p><h3>Precisão-Revocação</h3><p>O <em>trade-off</em> de Precisão-Revocação é particularmente relevante em tarefas de classificação. Precisão calcula a proporção de classificações positivas corretas, enquanto revocação mede a proporção de positivos reais corretamente identificados. Em muitos casos, aumentar a precisão pode resultar em uma diminuição na revocação e vice-versa.</p><h4>Trade-Offs na prática: estudos de caso de câncer de pele e COVID-19</h4><p>Ilustrando as implicações do gerenciamento de trade-offs, compartilho minhas experiências na criação de modelos de Aprendizado de Máquina para prever a COVID-19 em pacientes e classificar imagens de lesões de câncer de pele. <a href="https://github.com/pedrocrp/data_projects/tree/main/image_processing_and_classification"><strong><em>(Você pode ver mais sobre como eu fiz este projeto usando a extração de características de images com redes neurais e classificadores no meu GitHub).</em></strong></a></p><h4>Previsão da COVID-19</h4><p>No contexto da COVID-19, prever um paciente como não infectado pode ter implicações catastróficas, potencialmente levando à propagação do vírus de maneira desenfreada, além de pôr a vida do paciente em risco. Consequentemente, eu priorizei a revocação (minimizando falsos negativos) em vez da precisão, usando técnicas como ajustar o limiar de classificação e sobreamostragem de casos positivos.</p><h4>Classificação de câncer de pele</h4><p>Da mesma forma, no diagnóstico de câncer de pele, um falso negativo (classificar erroneamente um câncer maligno como benigno) poderia adiar tratamentos críticos e colocar em risco a vida do paciente. Aqui, a sensibilidade do modelo era vital, mesmo à custa de um aumento nos falsos positivos. É preferível encaminhar um paciente para testes adicionais do que perder um caso potencialmente maligno.</p><h3>Mas quando devemos priorizar a precisão?</h3><p>Vamos considerar o exemplo de um sistema de detecção de spam em e-mails. Este é um caso em que os falsos positivos podem ter efeitos mais prejudiciais do que os falsos negativos. Neste contexto, um falso positivo ocorre quando um e-mail legítimo — como um importante e-mail de trabalho ou uma mensagem pessoal de um amigo — é erroneamente marcado como spam e movido para a pasta de spam.</p><p>Tal cenário pode ter implicações sérias. Por exemplo, perder um importante e-mail de trabalho pode levar a prazos perdidos ou falhas de comunicação dentro de uma equipe. Perder uma mensagem pessoal de um amigo pode levar a mal-entendidos ou oportunidades perdidas. Estas são situações que a maioria dos usuários preferiria evitar.</p><p>Por outro lado, um falso negativo neste caso — onde um e-mail de spam não é reconhecido como tal e acaba na caixa de entrada do usuário — é normalmente menos grave. Embora possa ser chato receber spams, geralmente nós identificamos rapidamente e ignoramos (ou excluímos) essas mensagens sem consequências significativas.</p><p>Portanto, no caso da detecção de spam, a prioridade geralmente é minimizar os falsos positivos, mesmo à custa de tolerar uma taxa um pouco maior de falsos negativos. O algoritmo é projetado com um viés para garantir que e-mails legítimos não sejam classificados erroneamente como spam, reconhecendo o maior impacto negativo que este tipo de erro pode ter na experiência do usuário.</p><h3>Elevando a precisão dos nossos modelos</h3><ul><li>Refinando o <em>Decision Threshold</em>: Modelos de classificação normalmente geram saídas probabilísticas, com a previsão de classe final determinada com base em um limiar definido, geralmente fixado em 0.5. Ao aumentar este limiar, o modelo se torna mais conservador ao prever instâncias positivas, reduzindo assim a probabilidade de falsos positivos e, consequentemente, aumentando a precisão.</li><li>Usando <em>Feature Engineering</em>: O processo de engenharia de <em>features</em>, engloba a criação de novas <em>features</em> ou aprimoramento das existentes, pode melhorar substancialmente a precisão.</li><li>Escolhendo o Classificador Certo: Alguns modelos de aprendizado de máquina são naturalmente melhores em minimizar falsos positivos. Faça testes e veja qual modelo gera o menor número de falsos positivos.</li></ul><h3>Elevando a revocação dos nossos modelos</h3><ul><li>Ajustando o <em>Decision Threshold</em>: Reduzir o limiar para classificar uma previsão como positiva pode levar a uma revocação melhorada. Isso ocorre porque mais instâncias serão previstas como pertencentes à classe positiva.</li><li>Equilibre suas classes gerando novos exemplos na classe minoritária. Se a classe positiva em seu conjunto de dados está sub-representada, técnicas como a <em>Synthetic Minority Over-sampling Technique</em> (<em>SMOTE</em>) ou a <em>Data Augmentation</em> podem ser utilizadas.</li><li>Escolhendo o classificador certo: Novamente, faça testes e veja qual modelo gera o menor número de falsos positivos.</li></ul><h3>Encontrando um Equilíbrio: O Papel da métrica F1-Score</h3><p>Em cenários onde é crucial manter um equilíbrio entre precisão e revocação, o <em>F1-Score</em> pode servir como uma métrica útil. Essa métrica é a média harmônica de precisão e revocação, garantindo que ambas as métricas sejam levadas em conta. Diferente da média aritmética, a média harmônica dá um valor menor quando os números no conjunto têm maior disparidade, o que significa que um alto <em>F1-Score</em> requer que tanto a precisão quanto a revocação sejam altas.</p><p>Consequentemente, este pode atuar como métrica de avaliação útil em casos onde nem a precisão nem a revocação devem ser comprometidas. Otimizar para o <em>F1-Score</em> pode guiar seu modelo a encontrar um ponto de equilíbrio onde tanto a precisão quanto a revocação são maximizadas, resultando em um modelo mais equilibrado e confiável.</p><h3>Conclusão: Navegando pelos Trade-offs na jornada do Aprendizado de Máquina</h3><p>Encontrar <em>trade-offs</em> é uma parte inevitável do aprendizado de máquina. Cada problema tem necessidades únicas e requer abordagens personalizadas para a seleção e ajuste do modelo. Seja gerenciando viés-variação, ajustando precisão e revocação, ou buscando um equilíbrio entre eles, entender essas situações é essencial.</p><p>À medida que aproveitamos a jornada de aprendizado, devemos lembrar que não se trata apenas de construir modelos, trata-se de construir modelos eficazes, conscientes das implicações práticas. O equilíbrio que encontramos molda o impacto real de nossas soluções no mundo real.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a4c382846a3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scrape multiple webpage with BeautifulSoup and Regex]]></title>
            <link>https://medium.com/@pedrorp/scrape-multiple-webpage-with-beautifulsoup-and-regex-14a3ab21e570?source=rss-4c0cffa176c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/14a3ab21e570</guid>
            <category><![CDATA[web-scraping]]></category>
            <category><![CDATA[league-of-legends]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[regex]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Pedro César Ribeiro Passos]]></dc:creator>
            <pubDate>Wed, 28 Dec 2022 19:57:52 GMT</pubDate>
            <atom:updated>2022-12-28T20:13:07.371Z</atom:updated>
            <content:encoded><![CDATA[<p>Combine BeautifulSoup, Regex and Loops to get any kind of information (images, links, texts) from multiple web pages.</p><blockquote><strong>Disclaimer 1</strong>: All data used in this post is taken from the website “<a href="https://www.fandom.com/">https://www.fandom.com/</a>&quot;. All credits are reserved for this one.</blockquote><blockquote><strong>Disclaimer 2</strong>: All data used here comes from results of world championships held by Riot Games.</blockquote><p>League of Legends is a multiplayer online battle arena (MOBA) genre video game developed by <strong>Riot Games</strong>. For a long time I had fun playing this game, and one night thinking of some <strong>Data</strong> project that I could do in my spare time, the idea of ​​the project came up and I divided it into a few parts:</p><ul><li><strong>Data scraping</strong> on a webpage (the one I’ll show in this post)</li><li>Database <strong>creation</strong> and <strong>upload</strong> with Python</li><li><strong>Exploratory analysis</strong> of extracted data</li></ul><p>In this post I will show how I extracted all the data from different tables with different data types (e.g., images, links) just with BeautifulSoup module and Regex.</p><p>So, let’s do it!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgfycat.com%2Fifr%2Fplasticadeptasianpiedstarling&amp;display_name=Gfycat&amp;url=https%3A%2F%2Fgfycat.com%2Fplasticadeptasianpiedstarling-shia-labeouf-just-do-it-waiting-reddevils&amp;image=https%3A%2F%2Fthumbs.gfycat.com%2FPlasticAdeptAsianpiedstarling-size_restricted.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=gfycat" width="268" height="200" frameborder="0" scrolling="no"><a href="https://medium.com/media/7e6655f9e6eff0f5957206ed0cee2078/href">https://medium.com/media/7e6655f9e6eff0f5957206ed0cee2078/href</a></iframe><h4>1.First Steps</h4><p>When making a bot for Web Scraping it is important that you analyze 3 fundamental things:</p><ul><li>The URL of the page</li><li>How the data you need is structured</li><li>If there are differences between the multiple pages that will have your data extracted (in this post there will be a situation like this, I’ll explain later)</li></ul><p>Let’s extract data from all League of Legends World Championships so far (2011–2022). Analyzing the page with the Match History of each championship, we notice that they all have the same table structure, but from 2017 onwards it is divided into two tables due to having two different moments of the championship, the Play-In and the Main Event.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hWk1sr8OmHm26Pzf_qfz0g.png" /><figcaption>Structure of the table that will have your data scraped</figcaption></figure><p>As you can see, the structure of the table is as follows (we are counting columns from left to right):</p><ul><li>Column 1 and 2 has text data</li><li>Column 3 to 9 has data with images. Columns 6,7,8 and 9 have multiple data, that is, in the same column we can find up to 5 images together</li><li>Columns 11 and 12 have multiple comma-separated text data</li><li>There are other columns, but they will not be relevant for us</li></ul><p>Analyzing the URLs of the pages, we can find a pattern between them:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/426/1*tRaE9jRmi88DDZFOauXfTg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/431/1*NohtnMdyux7MH47CKuCdsQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/449/1*aw_CLjmfgNxaGNCaWrthPg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*FHrE4iNhm_ltRhMF02-61g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/527/1*0dqumIaC1VVY-mHKPuJ3aQ.png" /></figure><p>As you can see, the URLs of each page change according to the year, or as previously mentioned, they change according to the time of the event.</p><p><strong>This is the first lesson we can draw from this analysis</strong>. If you need to scrape data from multiple pages with a similar “look” you will probably just need to understand the structure of the URLs and iterate through the variable part of each one.</p><h4>2. Diving into code</h4><p>If you managed to understand well, you could see that what changes in each url is between “lol.fandom.com/wiki/” and “Match_History”. Below is how I grouped all variable parts of URLs into a list of tuples along with event season and timing (play-in or main):</p><pre>end_points = [<br>    (&#39;Season_1_World_Championship&#39;, 1,&#39;Main&#39;), <br>    (&#39;Season_2_World_Championship&#39;, 2, &#39;Main&#39;),<br>    (&#39;Season_3_World_Championship&#39;, 3,&#39;Main&#39;),<br>    (&#39;2014_Season_World_Championship&#39;, 4,&#39;Main&#39;),<br>    (&#39;2015_Season_World_Championship&#39;, 5,&#39;Main&#39;),<br>    (&#39;2016_Season_World_Championship&#39;, 6,&#39;Main&#39;),<br>    (&#39;2017_Season_World_Championship/Play-In&#39;,7, &#39;Play in&#39;),<br>    (&#39;2017_Season_World_Championship/Main_Event&#39;,7, &#39;Main&#39;),<br>    (&#39;2018_Season_World_Championship/Play-In&#39;,8,&#39;Play in&#39;),<br>    (&#39;2018_Season_World_Championship/Main_Event&#39;,8, &#39;Main&#39;),<br>    (&#39;2019_Season_World_Championship/Play-In&#39;, 9, &#39;Play in&#39;),<br>    (&#39;2019_Season_World_Championship/Main_Event&#39;, 9, &#39;Main&#39;),<br>    (&#39;2020_Season_World_Championship/Play-In&#39;, 10, &#39;Play in&#39;),<br>    (&#39;2020_Season_World_Championship/Main_Event&#39;, 10, &#39;Main&#39;),<br>    (&#39;2021_Season_World_Championship/Play-In&#39;, 11,&#39;Play in&#39;),<br>    (&#39;2021_Season_World_Championship/Main_Event&#39;,11, &#39;Main&#39;),<br>    (&#39;2022_Season_World_Championship/Play-In&#39;, 12, &#39;Play in&#39;),<br>    (&#39;2022_Season_World_Championship/Main_Event&#39;, 12, &#39;Main&#39;)<br>]</pre><p>Thinking about how I made the code, it would be possible to have another approach, such as iterating with a counter in the string <em>“{year}_Season_World_Championship”</em>. But it’s up to you to think about the best way to meet your demand.</p><p>Now, we need to create the function that will be responsible for the scraping itself. What the function needs to do is:</p><ul><li>Extract all HTML code from each page</li><li>Find only the data we want for the analysis (the table with historical data, in this case)</li><li>Since we have the HTML code of the table, we only need to extract the useful information (in an HTML code there is a lot of unnecessary information for data analysis)</li><li>Each line of the table will be represented by a list, and each list will be stored in a larger list, which in the future will be used to create a Dataframe with the Pandas module, so that we can analyze the results obtained in the scraping</li><li>With the data scraped and practically ready, we will make the final adjustments, for example, separating the values ​​that are in a single column by 3 or more</li></ul><h4>3. Creating the most important part, the scraping function</h4><p>Now we need to create two functions. The first function will be responsible for the first 4 points listed above. The second function will be responsible for treating the raw data and leaving the table as organized as possible so that it can be used for future analysis.</p><p><strong>3.1. The scraping function structure</strong></p><p>Here is the code of the complete function, I will explain in parts all its operation:</p><pre>def scraping(end_point):<br>    # We are extracting the desired table by looking for it <br>    # by its tag and its specific class name()<br>    soup = BeautifulSoup(requests.get(f&quot;https://lol.fandom.com/wiki/{end_point}/Match_History&quot;).content, &quot;html.parser&quot;)<br>    table = soup.find(&quot;table&quot;,{&quot;class&quot;:&quot;wikitable hoverable-multirows mhgame sortable plainlinks column-show-hide-1&quot;})<br>    table_rows = table.find_all(&#39;tr&#39;,class_ = [&#39;mhgame-red multirow-highlighter&#39;, &#39;mhgame-blue multirow-highlighter&#39;])<br>    table_list = []<br>    <br>    # Once our table is found, let&#39;s iterate through all the &quot;tr&quot; in our soup<br>    for tr in table_rows:<br>        col = 1<br>        row = []<br>        for td in tr:<br>        # As there are columns with different data types, each one <br>        # receives a different treatment<br>            if col in [3,4,5]:<br>                a = td.find(&#39;a&#39;)<br>                x = re.search(&quot;&quot;&quot;[a-z]{4}[-][a-z]{2}[-][a-z]{2}[=][&quot;][a-zA-Z0-9_[-]{1,}[&quot;]&quot;&quot;&quot;, a.__str__())<br>                if x is not None:<br>                    string = x[0][11:]<br>                    row.append(string.replace(&#39;&quot;&#39;,&quot;&quot;))<br>                <br>            elif col in [6,7,8,9]:<br>                span = td.findAll(&#39;span&#39;)<br>                champions = &#39;&#39;<br>                for i in span:<br>                    if i == span[-1]:<br>                        x = re.search(&quot;&quot;&quot;[a-z]{5}[=][&quot;][A-Z a-z&#39;]{1,}[&quot;]&quot;&quot;&quot;, i.__str__())<br>                        if x is not None:<br>                            string = x[0][6:]<br>                            champions += string.replace(&#39;&quot;&#39;,&quot;&quot;)<br>                        <br>                    else:<br>                        x = re.search(&quot;&quot;&quot;[a-z]{5}[=][&quot;][A-Z a-z.&#39;]{1,}[&quot;]&quot;&quot;&quot;, i.__str__())<br>                        if x is not None:<br>                            string = x[0][6:]<br>                            champions += string.replace(&#39;&quot;&#39;,&quot;&quot;) + &#39;,&#39;<br>                row.append(champions)<br><br>            else:<br>                row.append(td.text)<br>            col += 1<br>        <br>        table_list.append(row)<br>    <br>    initial_columns = [<br>            &#39;date&#39;,<br>            &#39;patch&#39;,<br>            &#39;blue_team&#39;,<br>            &#39;red_team&#39;,<br>            &#39;winner&#39;,<br>            &#39;bans_blue_team&#39;,<br>            &#39;bans_red_team&#39;,<br>            &#39;picks_blue_team&#39;,<br>            &#39;picks_red_team&#39;,<br>            &#39;blue_team_roster&#39;,<br>            &#39;red_team_roster&#39;,<br>            &#39;sb&#39;,<br>            &#39;vod&#39;<br>            ]<br>    df = pd.DataFrame(data = table_list,columns=initial_columns) <br>    return df</pre><p>The function has a single parameter, each <em>end_points</em> list element. Each iteration will change the endpoint, and as a result a new page will be scraped. As explained before, with the BeautifulSoup module we will fetch the table with the information we need.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*ip5zYOptvzclmHQEKTRdDg.png" /><figcaption>We are looking for the &lt;table&gt; tag</figcaption></figure><p>As you can see in the image above and in the code, the first thing to do is fetch the &lt;table&gt; tag with BeautifulSoup. It is important to point out that the name of the “class” table that we are looking for in the code is slightly different from the name that we see in the image. This is due to the fact that<em> “wikitable sortable jquery-tablesorter” </em>does not appear when navigating the website until the column is sorted. To avoid this I deleted the part “<em>jquery-tablesorter”.</em></p><p>With the table in hand, we will look for each line of it with the <em>findAll</em> method (searching for each &lt;tr&gt; tag). Then, let’s use a nested loop to iterate through all rows and each column in each row.</p><p>In each column there are different types of data, so there are different conditional loops for handling each type.</p><ul><li>Columns with text values ​​do not need to be treated differently, so we use the “.text” method:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/287/1*QvS3HgDQ4kaT5U77vUPR1g.png" /><figcaption>Whenever you want to get text values, use .text</figcaption></figure><ul><li>Columns with images have a <em>&lt;a&gt; tag</em> inside, which defines a hyperlink, which is used to link from one page to another. The treatment for this type of situation will be explained below.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/666/1*RITBmuWvflVsYfxD6ggkrA.png" /><figcaption>How can we access the “<strong>data-to-id</strong>” value of each image in the table?</figcaption></figure><ul><li>There are also columns with images that don’t carry a hyperlink with them. These columns have <em>&lt;span&gt; tags</em>, which are an inline container.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/1*TS7uzRCUmi-IFvYe9DuvnQ.png" /><figcaption>How can we access the “<strong>title</strong>” value of each image in the table?</figcaption></figure><p><strong>3.2. Using regex and __str__() to get any data from a page</strong></p><p>A regular expression, or Regex, are patterns used to identify certain combinations or strings of characters in a string. Let’s use regex to find exactly the information we want from each of the tags described above. As you can see, all the information we want is in a standard format, be it <em>data-to-id=”{team}”</em> or <em>title=”{champion}”.</em></p><p>So, using the site <a href="https://regex101.com/">https://regex101.com/</a>, let’s create our regex (I won’t explain much about regular expressions because it’s not the purpose of the article, but you can get excellent explanations on other platforms). With this site, it is possible to build regular expressions even if you are not an expert in it, and test to see if there is a match with the desired string.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/972/1*_xLWfNZ2wQBLlAH4f2YbKg.png" /><figcaption>This site helps you test whether your regular expression matches the string you want.</figcaption></figure><p>But, to use <em>re.search(), </em>the<em> </em>parameter must be a string. In our case, we don’t have a string, but an<strong> object resulting from the search using BeautifulSoup</strong>. To resolve this, I used a special python method used to return a string representation of an object, the <em>__str__()</em>.</p><p>In this part of the code we use “<em>i.__str__()” </em>to<em> </em>each search object from the <em>&lt;span&gt;</em> tag and turn it into a string. With this string we look for similarities with the regular expression and once we find the string we want, we add it to a new string called <em>“champions” </em>(columns [6,7,8,9]) or we get the team name by slicing (columns [3, 4, 5]).</p><p><strong>3.3. Creating the dataframe</strong></p><p>Now that we have the list with lists carrying the information from each row of the table, we just need to create the dataframe representing each table. I used the initial name of each column for better visualization, but it is not a mandatory step.</p><h4>4. Organizing the Dataframe and separating the columns</h4><p>With the Dataframe in hand, all that remains is to separate the columns.</p><pre>df[[&#39;ban_1_blue_team&#39;,&#39;ban_2_blue_team&#39;,&#39;ban_3_blue_team&#39;]] = df[&#39;bans_blue_team&#39;].str.split(&#39;,&#39;,expand=True)</pre><p>Here is an example of the code syntax we will be using to separate different columns. This will repeat for all Dataframe columns that have more than one value. It is important to emphasize that all columns that participate in this process have strings with words separated by commas like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/276/1*mHH1Xi13Q6eVAC0Pmukxpw.png" /><figcaption>One column with multiple values</figcaption></figure><h4>5. The finals</h4><p>After so many explanations, we arrived at the final code, a merger of the two functions into a single one, to optimize the process of creating a large Dataframe with all the data.</p><pre>def scrape_table(end_point):<br>    try:<br>        original_df = scraping(end_point)<br>        return df_organize(original_df, end_point)<br>    except:<br>        raise &#39;Error, please verify functions&#39;</pre><p>Now the last step is to create the loop around our list of endpoints, so that all the pages are scraped and we have as a result a big Dataframe with all the game data from the first season.</p><pre>columns = [<br>        &#39;date&#39;,<br>        &#39;season&#39;,<br>        &#39;event&#39;,<br>        &#39;patch&#39;,<br>        &#39;blue_team&#39;,<br>        &#39;red_team&#39;,<br>        &#39;winner&#39;,<br>        &#39;ban_1_blue_team&#39;,<br>        &#39;ban_2_blue_team&#39;,<br>        &#39;ban_3_blue_team&#39;,<br>        &#39;ban_4_blue_team&#39;,<br>        &#39;ban_5_blue_team&#39;,<br>        &#39;ban_1_red_team&#39;,<br>        &#39;ban_2_red_team&#39;,<br>        &#39;ban_3_red_team&#39;,<br>        &#39;ban_4_red_team&#39;,<br>        &#39;ban_5_red_team&#39;,<br>        &#39;pick_1_blue_team&#39;,<br>        &#39;pick_2_blue_team&#39;,<br>        &#39;pick_3_blue_team&#39;,<br>        &#39;pick_4_blue_team&#39;,<br>        &#39;pick_5_blue_team&#39;,<br>        &#39;pick_1_red_team&#39;,<br>        &#39;pick_2_red_team&#39;,<br>        &#39;pick_3_red_team&#39;,<br>        &#39;pick_4_red_team&#39;,<br>        &#39;pick_5_red_team&#39;,<br>        &#39;top_blue_team&#39;,<br>        &#39;jungler_blue_team&#39;,<br>        &#39;mid_blue_team&#39;,<br>        &#39;adc_blue_team&#39;,<br>        &#39;support_blue_team&#39;,<br>        &#39;top_red_team&#39;,<br>        &#39;jungler_red_team&#39;,<br>        &#39;mid_red_team&#39;,<br>        &#39;adc_red_team&#39;,<br>        &#39;support_red_team&#39;<br>        ]<br>appended_data = []<br>for end_point in end_points:<br>    data = scrape_table(end_point[0])<br>    data[&#39;season&#39;] = end_point[1]<br>    data[&#39;event&#39;] = end_point[2]<br>    appended_data.append(data)<br>df_worlds = pd.concat(appended_data)<br>df_worlds = df_worlds[columns]<br>df_worlds.set_index(&#39;season&#39;, inplace=True)</pre><p>Note that this new columns list is used to reorder the columns the way I want the final Dataframe to look, this step isn’t really necessary. Two new columns are created with the values ​​that I inserted in the <em>end_points</em> list in tuple format, for better organization and separation of each event and season.</p><p>Each Dataframe originating from data scraping is stored in a list for concatenation of all and result in a single large Pandas-like object. With that, we have a Dataframe with all the match data from the League of Legends world championships. Now we can do analysis and predictions.<strong> But that will be in a next article!</strong></p><h4><strong>6. Thank You!!</strong></h4><p>If you’ve made it this far, I’d like to thank you for your interest, I hope I’ve helped you in some way. This was a Data Engineering and Web Scraping project. My ultimate goal is an end-to-end project from ETL to data analysis. With that, the first stage ends here.</p><p>In addition to this set of data from the matches, I created using a similar logic other functions that scraped data related to the historical data of champions and players in the League of Legends World Championship. The full notebook is on my GitHub, please check it out if you’re interested!</p><p>The final dataset is available on <a href="https://www.kaggle.com/datasets/pedrocsar/league-of-legends-worlds-20112022-stats">Kaggle</a></p><p>If you want to chat, feel free to contact me on my <a href="https://www.linkedin.com/in/pedrocesarrp/">Linkedin</a></p><p>Finally, see the full code on my <a href="https://github.com/pedrocrp/python_projects/tree/main/worlds_lol_scraping">GitHub</a></p><p>See ya!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgfycat.com%2Fifr%2Fadeptashamedasianporcupine&amp;display_name=Gfycat&amp;url=https%3A%2F%2Fgfycat.com%2Fadeptashamedasianporcupine-bye&amp;image=https%3A%2F%2Fthumbs.gfycat.com%2FAdeptAshamedAsianporcupine-size_restricted.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=gfycat" width="500" height="323" frameborder="0" scrolling="no"><a href="https://medium.com/media/19304f385293dc10a3935195d838179f/href">https://medium.com/media/19304f385293dc10a3935195d838179f/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=14a3ab21e570" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>