Aprendizado de máquina e redes neurais - página 69
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
5.5 Scikit-learn Transformer API (L05: Machine Learning com Scikit-Learn)
5.5 Scikit-learn Transformer API (L05: Machine Learning com Scikit-Learn)
No vídeo, o apresentador se aprofunda no processo de preparação de um conjunto de dados de treinamento usando utilitários do scikit-learn e apresenta a API do transformador, que está intimamente relacionada à API do estimador discutida em um vídeo anterior. A API do estimador é usada principalmente para modelos de aprendizado supervisionado, como classificadores e modelos de análise de regressão, enquanto a API do transformador é projetada para transformações de dados.
O apresentador começa abordando os problemas associados à subamostragem aleatória, que envolve a divisão de um conjunto de dados em dois subconjuntos, geralmente um conjunto de treinamento e um conjunto de teste. Eles explicam que a divisão aleatória do conjunto de dados pode levar a mudanças na distribuição dos rótulos das classes, resultando em uma representação incorreta das classes nos conjuntos de treinamento e teste. Para superar esse desafio, o apresentador sugere o uso da divisão estratificada, que garante que a distribuição ou proporções de classes sejam mantidas nos subconjuntos. Eles demonstram como obter a divisão estratificada usando a função train_test_split do submódulo model_selection do scikit-learn.
Seguindo em frente, o apresentador se aprofunda no conceito de normalização de dados, com foco específico em duas técnicas: escalonamento min-max e padronização. O dimensionamento mínimo-máximo envolve o dimensionamento de um recurso para que todos os seus valores caiam no intervalo de 0 a 1. O apresentador fornece a fórmula para o dimensionamento mínimo-máximo, que envolve a subtração de cada valor na coluna do recurso pelo valor mínimo do recurso e, em seguida, a divisão pela diferença entre os valores máximo e mínimo do recurso.
Em contraste, a padronização envolve transformar um recurso para ter uma média de zero e um desvio padrão de um. O apresentador explica a fórmula de padronização, que consiste em subtrair cada valor da coluna de feição pela média da feição e depois dividir pelo desvio padrão da feição. Eles mencionam que a padronização é mais comumente usada em aprendizado de máquina e é particularmente útil para certos algoritmos de otimização.
Para ilustrar a aplicação prática de dimensionamento e padronização min-max, o apresentador fornece exemplos usando colunas de recursos de brinquedo. Eles enfatizam que a escolha entre usar o desvio padrão da amostra ou da população não afeta significativamente os resultados do aprendizado de máquina, desde que os recursos estejam centralizados e tenham aproximadamente variação de unidade. Além disso, eles destacam a importância de usar os parâmetros (média e desvio padrão) calculados a partir do conjunto de treinamento para dimensionar os conjuntos de validação e teste, pois os conjuntos de validação e teste representam dados não vistos.
O vídeo continua explorando várias técnicas para transformação e manipulação de dados em aprendizado de máquina. Ele reconhece que, para procedimentos simples como padronização, é possível realizar as transformações manualmente sem depender de bibliotecas separadas ou técnicas avançadas. No entanto, para transformações mais complexas, como seleção de recursos, redução de dimensionalidade de recursos e extração de recursos, o uso de ferramentas como a API do Transformer pode oferecer maior conveniência e eficiência.
Em seguida, o apresentador se concentra em lidar com dados categóricos. Eles apresentam um conjunto de dados de brinquedos composto por três colunas de recursos e uma coluna de rótulos, enfatizando que as variáveis categóricas podem ser classificadas em dois tipos: ordinais e nominais. As variáveis ordinais possuem uma ordem ou hierarquia específica, enquanto as variáveis nominais não. Como ilustração, eles destacam a coluna "tamanho" como uma variável ordinal, onde tamanhos de camisetas como M, L e XXL exibem uma ordem clara. Para lidar com variáveis ordinais, o vídeo recomenda o emprego de um dicionário de mapeamento para transformar os valores em representações numéricas.
Por outro lado, o vídeo apresenta rótulos de classe como um exemplo de dados categóricos nominais. Como não há ordem inerente entre os rótulos de classe, o apresentador sugere usar o codificador de rótulo para atribuir valores inteiros exclusivos a cada rótulo. O codificador de rótulo é ajustado na coluna de rótulo de classe para criar um dicionário de mapeamento, que é então usado para transformar os rótulos de string em rótulos inteiros.
Para colunas de recursos nominais como "cor", onde nenhuma ordem está implícita, a utilização do codificador de rótulo pode apresentar informações enganosas. Nesses casos, o vídeo apresenta a codificação one-hot como uma alternativa adequada. Essa técnica envolve a criação de uma nova coluna de recursos para cada valor distinto na coluna de recursos nominais e a atribuição de 0s e 1s para indicar a presença ou ausência de um valor específico. É mencionado que descartar uma das colunas de recursos resultantes pode eliminar a redundância sem perder informações essenciais.
O vídeo aborda brevemente os dados ausentes e propõe algumas abordagens básicas para lidar com eles. Uma estratégia envolve descartar linhas ou colunas contendo valores ausentes se eles ocorrerem aleatoriamente e não indicarem um problema sistemático. Isso pode ser feito usando o método dropna() na biblioteca pandas. Outra abordagem é imputar dados ausentes preenchendo as lacunas com medidas estatísticas, como média ou mediana, empregando ferramentas como o transformador SimpleImputer. No entanto, o vídeo adverte que a imputação deve ser considerada com cuidado, pois pode introduzir vieses não intencionais.
Além disso, o vídeo menciona a possibilidade de prever valores ausentes tratando o problema como uma tarefa de aprendizado supervisionado. Nesse cenário, a coluna de recurso ausente pode ser considerada a variável de destino e as linhas sem dados ausentes podem ser utilizadas como dados de treinamento para ajustar um modelo de regressão.
O vídeo fornece uma visão geral abrangente das técnicas de transformação de dados, incluindo a importância de preparar um conjunto de dados de treinamento, a aplicação da divisão estratificada e a normalização de dados usando escala e padronização min-max. Abrange ainda a manipulação de dados categóricos, distinguindo entre variáveis ordinais e nominais e apresenta técnicas como dicionários de mapeamento, codificadores de rótulo e codificação one-hot. Além disso, o vídeo aborda brevemente dados ausentes e descreve abordagens, como descartar ou imputar valores ausentes, além de mencionar a possibilidade de prever valores ausentes por meio do aprendizado supervisionado.
5.6 Pipelines Scikit-learn (L05: Machine Learning com Scikit-Learn)
5.6 Pipelines Scikit-learn (L05: Machine Learning com Scikit-Learn)
Tudo bem, pessoal, finalmente chegamos à última parte da Aula 5, que é, na minha opinião, a mais interessante: canais sagrados de aprendizado. Esses pipelines são objetos ou classes incrivelmente úteis que nos permitem combinar processamento de dados e etapas de previsão perfeitamente. Para lhe dar uma visão geral, apresentarei um fluxograma de como os pipelines funcionam, embora ainda não me aprofunde em todos os detalhes.
Pense em um pipeline como um estimador com uma API transformadora. Semelhante a um estimador, um pipeline possui um método de ajuste que podemos usar no conjunto de treinamento. Internamente, o pipeline passa por várias etapas de ajuste e transformação e, por fim, chega à etapa de ajuste final. Dependendo do que definimos em nosso pipeline, ele pode executar várias tarefas, como dimensionamento de dados (por exemplo, padronização ou dimensionamento min-max), redução de dimensionalidade, treinamento de um algoritmo de aprendizado e retorno de um modelo preditivo que podemos usar no conjunto de teste .
Quando chamamos o método de previsão no conjunto de teste, semelhante à API do estimador, o pipeline usa internamente a etapa de transformação para aplicar o mesmo escalonamento que foi realizado no conjunto de treinamento. Isso garante consistência no processamento de dados. Por fim, o pipeline usa o modelo ajustado para fazer previsões, como retornar rótulos de classe no caso de um classificador.
Deixe-me ilustrar isso com um exemplo de código simples de um pipeline. Aqui, estou criando um pipeline usando a função make_pipeline do submódulo sklearn.pipeline do sagrado aprendizado. Essa é uma maneira conveniente de criar pipelines. Neste exemplo, estou construindo um pipeline básico que consiste em um dimensionador padrão e um classificador de K vizinho mais próximo. O scaler padrão, como discutimos no vídeo anterior, padroniza os dados fazendo com que tenham média zero e variância unitária. Inicializamos o escalador padrão e o classificador K-vizinho mais próximo como componentes do pipeline.
Depois que o pipeline é criado, podemos usar o método fit para treinar o pipeline nos dados de treinamento. Então, podemos usar o método predict para fazer previsões no conjunto de teste. Quando chamamos de ajuste, o pipeline primeiro aplica o dimensionador padrão para aprender a média e o desvio padrão dos dados de treinamento. Em seguida, ele usa essas informações para dimensionar os dados, que são passados para a próxima etapa, o classificador K-vizinho mais próximo. O classificador recebe o conjunto de treinamento padronizado e executa seu algoritmo de aprendizado.
Durante a previsão, o mesmo processo acontece, exceto que não há necessidade de uma etapa de ajuste. O pipeline reutiliza as estatísticas aprendidas durante o treinamento para dimensionar os dados de teste e aplica o classificador aprendido para fazer previsões.
Para resumir, um pipeline nos permite encadear vários objetos, como transformadores e estimadores, para criar um fluxo de trabalho coeso. Ele fornece uma maneira conveniente e eficiente de lidar com etapas de processamento e previsão de dados em tarefas de aprendizado de máquina.
Agora, vamos dar uma olhada em um pipeline em ação aplicando o método de validação simples para seleção de modelo. A seleção de modelos envolve o ajuste de hiperparâmetros para selecionar o melhor modelo. No método holdout, dividimos os dados em um conjunto de treinamento e um conjunto de teste. Dentro do conjunto de treinamento, nós o dividimos em um subconjunto para aprendizado e outro subconjunto para validação, onde avaliamos diferentes modelos com várias configurações de hiperparâmetros.
No scikit-learn, podemos executar o método de validação e o ajuste de hiperparâmetros usando um método chamado pesquisa de grade. A pesquisa de grade envolve a criação de uma grade de parâmetros que define as combinações de hiperparâmetros que queremos avaliar. Por exemplo, no caso de k-vizinhos mais próximos, podemos considerar valores diferentes para o número de vizinhos (k) e a métrica de distância (p). A pesquisa em grade itera sobre todas as combinações possíveis, ajustando os modelos no conjunto de treinamento e avaliando-os no conjunto de validação.
Embora a pesquisa de grade seja normalmente usada com validação cruzada K-fold, neste exemplo, vamos nos concentrar no método de validação. Para aplicar o método holdout e a pesquisa de grade usando um pipeline, podemos utilizar a classe GridSearchCV do scikit-learn. Esta classe nos permite definir a grade de parâmetros e o pipeline, e trata do processo de ajuste dos modelos e avaliação dos mesmos.
Aqui está um trecho de código de exemplo para demonstrar como usar GridSearchCV com um pipeline:
Em seguida, definimos a grade de parâmetros param_grid que especifica as diferentes combinações de hiperparâmetros que queremos avaliar. Neste caso, variamos o número de vizinhos (n_vizinhos) e a função de peso (pesos) para o classificador K-vizinho mais próximo. Observe que os nomes dos parâmetros na grade são prefixados com o nome do componente de pipeline seguido por um sublinhado duplo (__).
Criamos um objeto GridSearchCV, passando o pipeline, a grade de parâmetros e o número desejado de dobras de validação cruzada (cv). A classe GridSearchCV executa automaticamente a pesquisa de grade ajustando o pipeline nos dados de treinamento e avaliando os modelos no conjunto de validação.
Após a conclusão da pesquisa da grade, podemos acessar os melhores parâmetros e a melhor pontuação usando os atributos best_params_ e best_score_ do objeto GridSearchCV. Imprimimos esses valores para ver qual combinação de hiperparâmetro produziu o melhor desempenho.
Por fim, avaliamos o melhor modelo no conjunto de teste acessando-o a partir do atributo best_estimator_ do objeto GridSearchCV e calculando a precisão usando o método score.
Este exemplo demonstra como podemos aproveitar pipelines e pesquisa de grade para explorar com eficiência diferentes configurações de hiperparâmetros e selecionar o melhor modelo usando o método de validação. Ao combinar etapas de processamento de dados e treinamento de modelo em um pipeline, podemos simplificar o fluxo de trabalho de aprendizado de máquina e experimentar facilmente diferentes componentes e hiperparâmetros.
6.1 Intro to Decision Trees (L06: Decision Trees)
6.1 Intro to Decision Trees (L06: Decision Trees)
Finally, we are going to cover a new topic - decision trees. Decision tree algorithms can be considered as iterative top-down construction methods for classifiers and regression models. To keep the videos manageable and not too long, I have split the lecture into seven parts.
In the first part, we will provide a brief overview of decision trees, their conceptual representation, and introduce core terminology. Next, we will discuss recursive algorithms in the context of decision trees and briefly explain what recursive algorithms are. This understanding will help us analyze the runtime complexity (Big O) of decision trees.
Moving on, we will explore different types of decision trees. Currently, the second learner implements the CART (Classification and Regression Trees) decision tree algorithm developed by Leo Breiman. However, there are other algorithms like ID3 and C4.5, each with their own advantages and disadvantages. We will touch upon these different methods and might assign a homework exercise, possibly implementing the ID3 decision tree.
Within the lecture, we will also explore various splitting criteria used for decision trees. Currently, the second learner uses CART, which is typically based on Gini impurity. However, it allows for mixing and matching different splitting criteria. These splitting criteria refer to the functions or measures used to determine a good feature for splitting a decision tree. We will cover the Gini impurity and entropy criteria and discuss why they are preferred over the misclassification error when evaluating tree growth and split quality.
Once we have covered these details, we will delve into the improvements that can make decision trees more efficient in terms of computational runtime and classification accuracy. We will also address the challenge of overfitting and explore techniques to mitigate it.
Lastly, we will provide a code example that demonstrates working with decision trees in scikit-learn, a popular machine learning library. This practical example will help solidify your understanding of decision trees and their implementation.
Now, let's dive into the basic concept of a decision tree. While not strictly a machine learning problem, decision trees relate to everyday life scenarios involving decision-making. For instance, we can consider the decision of what to do at a given moment. If we have work to do, we may choose to stay inside and complete the work. Conversely, if we don't have any pending work, we can consider going outside, depending on the weather outlook.
Let's say, if it's sunny and not too cold, we may opt to go to the beach. However, if it's overcast, we might choose to go for a run instead. In the case of rain or snow, we could ask our friends about their availability. If our friends are busy, we might decide to stay inside and engage in activities like reading a book. On the other hand, if our friends are free, we can explore options like going to the movie theater, playing video games online, or having an online chat.
This basic outline represents a decision tree, where each node corresponds to a question or decision, and the branches lead to different options. The root node represents the first question or decision in the tree, while the leaf nodes are the final outputs. The internal nodes are the intermediary decisions that guide the flow of the tree.
Furthermore, the nodes in a decision tree can be categorized into binary or multi-category nodes. Binary nodes offer only two options, while multi-category nodes support more than two options. However, multi-category splits can be converted into binary splits, as discussed earlier.
Decision trees can also be interpreted as sets of rules, similar to if-else statements in programming. In fact, decision trees can be converted into rule sets, although the reverse conversion is not always possible. This characteristic of decision trees makes them highly interpretable and explainable, which is crucial in domains where interpretability and explainability are important, such as in legal and medical domains.
To construct a decision tree, we need a dataset that contains examples of inputs and corresponding outputs. Each example consists of a set of features (also known as attributes or predictors) and a target variable (the output we want to predict). The decision tree algorithm analyzes the features and their relationships to determine the best way to split the data and make predictions.
The process of building a decision tree involves selecting the best feature to split the data at each node. The goal is to find the feature that provides the most information gain or the best split in terms of classification accuracy. This process is typically performed recursively, starting from the root node and continuing down to the leaf nodes.
At each step, the algorithm evaluates different splitting criteria, such as Gini impurity or entropy. Gini impurity measures the probability of misclassifying a randomly chosen element from the set, while entropy measures the average amount of information required to identify the class label of a randomly chosen element from the set. These criteria help determine the purity of the resulting subsets after a split.
Once a feature is selected for splitting, the data is divided into subsets based on the possible feature values. This process is repeated recursively for each subset until a stopping criterion is met. The stopping criterion could be reaching a maximum tree depth, reaching a minimum number of samples in a leaf node, or achieving a certain level of purity in the leaf nodes.
To predict the target variable for a new instance using a trained decision tree, we start at the root node and traverse down the tree by following the appropriate branches based on the feature values of the instance. Eventually, we reach a leaf node, which provides the predicted output.
Decision trees have several advantages. They are easy to understand and interpret, making them a popular choice for visualizing and explaining the decision-making process. They can handle both numerical and categorical features, and they can be used for both classification and regression tasks. Decision trees are also robust to missing values and outliers, as they can handle them effectively during the splitting process.
However, decision trees also have some limitations. They can easily overfit the training data, resulting in poor generalization to unseen examples. This can be mitigated by using pruning techniques or employing ensemble methods like random forests or gradient boosting. Decision trees are also sensitive to small changes in the training data, and different splits can be generated for similar datasets. Additionally, decision trees may struggle to capture complex relationships between features.
In conclusion, decision trees are powerful and interpretable models that can be used for classification and regression tasks. They provide a clear decision-making framework by representing the data as a tree structure with nodes and branches. The choice of splitting criteria and stopping criteria, along with techniques to handle overfitting, play important roles in building accurate and robust decision trees.
6.2 Algoritmos Recursivos e Big-O (L06: Árvores de Decisão)
6.2 Algoritmos Recursivos e Big-O (L06: Árvores de Decisão)
Neste vídeo, nossa discussão gira em torno de algoritmos recursivos, que estão intimamente ligados ao conceito de dividir para conquistar. Dividir para conquistar envolve dividir um problema em subproblemas menores, resolvê-los individualmente e depois combinar as soluções. O treinamento e a previsão da árvore de decisão, bem como vários algoritmos de divisão e conquista, estão vinculados a esse conceito. A recursão é uma técnica comum usada para implementar algoritmos de divisão e conquista, embora não seja a única abordagem.
Para compreender a ideia de recursão, vamos examinar um exemplo de algoritmo recursivo implementado em Python. Para fins de discussão, escondi intencionalmente o nome real da função para incentivá-lo a analisar sua finalidade antes de nos aprofundarmos em seus detalhes. Eu encorajo você a parar um momento para pensar sobre o que esta função pode fazer. Você pode pausar o vídeo ou até mesmo experimentá-lo em um notebook Jupyter para entender seu comportamento.
Supondo que você tenha dedicado algum tempo para analisá-la, vamos explorar a função juntos. Essa função específica opera em listas do Python. Por exemplo, considere uma lista como [1, 2, 3]. O objetivo desta função é determinar o comprimento de uma matriz ou lista. Vamos examinar como funciona. A função recebe uma entrada, denotada como 'X' aqui, e verifica duas condições. Primeiro, ele verifica se a lista está vazia. Se for, a função retornará 0 porque uma lista vazia tem comprimento zero, que atua como condição de parada. Caso contrário, se a lista não estiver vazia, a função retorna 1 e chama a si mesma com uma entrada menor.
Se isso parece abstrato, vamos decompô-lo passo a passo. Suponha que começamos com uma lista completa, como [1, 2, 3]. Inicialmente, a função verifica se a lista está vazia, o que não está. Conseqüentemente, ele segue para a instrução 'else', onde retorna 1 e chama a si mesmo recursivamente com uma entrada menor. Nesse caso, a entrada torna-se [2, 3], pois removemos o primeiro elemento da lista original. Repetimos o processo: a função retorna 1 novamente, chama a si mesma com a nova entrada [3] e, finalmente, chama a si mesma com uma lista vazia.
Ao atingir a lista vazia, a função verifica novamente a condição 'if', que agora é verdadeira. Como resultado, retorna 0. Ao avaliarmos a expressão inteira, obtemos o valor 3. Portanto, esta função calcula o comprimento de um array usando recursão, onde a função chama a si mesma dentro de sua própria definição. Vale a pena notar que, embora a recursão seja uma solução conceitualmente elegante na teoria da ciência da computação, nem sempre pode ser a abordagem mais prática para implementação. Em Python, a recursão tem limitações no número de chamadas automáticas e listas excessivamente grandes podem causar um erro de estouro de pilha.
Continuando, vamos explorar outro exemplo que emprega recursão. Aqui, abordamos um problema de divisão e conquista — classificação de uma lista ou array — usando o algoritmo quicksort. Semelhante à função anterior, o quicksort usa a recursão como meio de implementação. O algoritmo emprega uma condição de parada, em que a função retorna a matriz como está se ela contiver menos de dois elementos. Caso contrário, o algoritmo executa a seção principal do código.
Como funciona o quicksort? Primeiro, selecionamos um pivô, normalmente o primeiro elemento do array. Em seguida, criamos duas novas listas: uma para conter os elementos menores que o pivô e outra para os elementos maiores que o pivô. Nós iteramos pela matriz, excluindo o pivô, e distribuímos cada elemento para a lista menor ou maior com base em sua comparação com o pivô. Em seguida, chamamos recursivamente o quicksort nas listas menores e maiores, usando o pivô como elemento central. Eventualmente, o
chamadas recursivas atingirão a condição de parada quando as listas tiverem menos de dois elementos. Nesse ponto, a função simplesmente retorna as listas classificadas.
Vamos percorrer um exemplo para entender o processo. Suponha que temos uma lista não ordenada [7, 2, 5, 1, 9, 3]. O algoritmo quicksort procederá da seguinte forma:
Ao dividir recursivamente a lista em sublistas menores e classificá-las, o algoritmo quicksort classifica a lista inteira com eficiência.
Em conclusão, os algoritmos recursivos desempenham um papel crucial nas abordagens de divisão e conquista. Eles dividem os problemas em subproblemas menores e os resolvem individualmente, eventualmente combinando as soluções para resolver o problema original. As funções recursivas chamam a si mesmas dentro de sua própria definição, trabalhando repetidamente em entradas menores até atingir uma condição de parada. No entanto, é importante considerar a condição de término para evitar a recursão infinita e garantir que o algoritmo convirja para uma solução.
6.3 Tipos de árvores de decisão (L06: Árvores de decisão)
6.3 Tipos de árvores de decisão (L06: Árvores de decisão)
Nos vídeos anteriores, focamos na introdução de árvores de decisão e algoritmos recursivos. Agora, vamos nos aprofundar nos diferentes tipos de árvores de decisão. Exploraremos como a alteração de certas escolhas de projeto pode levar a diferentes implementações de algoritmos de árvore de decisão.
Primeiro, vamos recapitular o algoritmo genérico da árvore de decisão em pseudocódigo, que discutimos no vídeo anterior. Lidamos com um problema de classificação binária, onde os rótulos das classes eram apenas 1 e 0. Nossa árvore seguia uma estrutura binária, envolvendo divisão binária. Isso significa que cada nó foi dividido em exatamente dois nós filhos. Além disso, consideramos apenas recursos binários, em que os valores dos recursos podem ser 0 ou 1.
No entanto, como demonstramos anteriormente usando a visualização da árvore de decisão no scikit-learn, também podemos utilizar recursos contínuos e convertê-los em divisões binárias. Por exemplo, podemos selecionar um recurso, vamos chamá-lo de xj, e dividi-lo em duas partes usando um limite, denotado como 't'. Esse critério de divisão pode ser definido como xj menor que t ou xj maior ou igual a t, que pode ser representado como verdadeiro ou falso. Isso nos permite realizar uma divisão binária mesmo com recursos contínuos, pois podemos ajustar o limite de decisão durante o processo de divisão. Você terá a oportunidade de trabalhar em tal divisão na lição de casa.
Agora, vamos nos concentrar na implementação do algoritmo de árvore de decisão. Em cada nó da árvore de decisão, consideramos um único recurso, denotado como xj, onde 'j' varia de 1 a m, representando até m recursos. Quando dividimos um nó pai em dois nós filhos, digamos filho zero e filho um, precisamos determinar qual recurso escolher para a divisão. Para recursos contínuos, também precisamos considerar o limite de decisão, onde comparamos se xj é maior ou igual a um valor específico 't'. Selecionar o recurso e o limite apropriados é crucial e exigimos uma medida de qualidade para avaliar a qualidade de uma divisão.
Para resumir o algoritmo genérico de crescimento de árvore, selecionamos o recurso que resulta no maior ganho de informação quando o nó pai é dividido. O ganho de informação é uma medida de qualidade para uma divisão. Quanto maior o ganho de informação, melhor a divisão e o recurso escolhido, incluindo seu limite de divisão para recursos contínuos. No próximo vídeo, discutiremos duas medidas comumente usadas para avaliar a qualidade de uma divisão: entropia e impureza de Gini.
O algoritmo segue certas condições de parada. Ele para se os nós filhos forem puros, o que significa que todos os pontos de dados em um nó têm o mesmo rótulo de classe. Alternativamente, ele para se o ganho de informação for menor ou igual a zero, indicando nenhuma melhoria. Uma vez que alcançamos um nó puro ou deixamos de progredir, paramos de aumentar ainda mais a árvore.
Depois de aumentar a árvore de decisão, podemos usá-la para fazer previsões. Suponha que temos uma árvore com vários níveis, compreendendo os nós pai e folha. Para prever o rótulo de classe de um novo ponto de dados, percorremos a árvore com base nos valores de recursos do ponto de dados. Em cada nó, seguimos o ramo correspondente com base nas condições do recurso até chegarmos a um nó folha. Para nós folha, usamos a abordagem de voto majoritário para determinar o rótulo da classe. Isso significa que prevemos o rótulo de classe que aparece com mais frequência nesse nó folha.
É importante observar que as árvores de decisão podem lidar com problemas de classificação binária e multiclasse. O pseudocódigo que discutimos nos slides anteriores focava na classificação binária, mas as árvores de decisão podem lidar com um número arbitrário de rótulos de classe. A abordagem de voto majoritário é aplicável independentemente do número de classes.
Ao desenvolver algoritmos de árvore de decisão, encontramos várias opções de design. Uma questão crucial é como dividir os nós. Precisamos definir o critério de divisão e determinar como comparar e avaliar diferentes divisões. As duas medidas comumente usadas para avaliar a qualidade de uma divisão são a entropia e a impureza de Gini.
A entropia é uma medida da impureza ou desordem dentro de um nó. Ele quantifica a incerteza associada aos rótulos de classe dos pontos de dados naquele nó. A entropia de um nó é calculada usando a seguinte fórmula:
Entropia(nó) = - soma(p(i) * log2(p(i))), para todas as classes i
onde p(i) representa a proporção de pontos de dados no nó que pertencem à classe i. O valor de entropia varia de 0 a 1, onde 0 indica um nó puro (todos os pontos de dados pertencem à mesma classe) e 1 indica impureza máxima (distribuição igual de pontos de dados em todas as classes).
Para avaliar a qualidade de uma divisão, calculamos a média ponderada dos valores de entropia para os nós filhos resultantes. Isso é conhecido como ganho de informação. O ganho de informação é calculado da seguinte forma:
Ganho de informação = Entropia(pai) - soma((|Sv| / |S|) * Entropia(Sv)), para todos os nós filhos v
onde Entropy(parent) é a entropia do nó pai, |Sv| representa o número de pontos de dados no nó filho v, e |S| é o número total de pontos de dados no nó pai. O ganho de informação mede a redução na entropia obtida pela divisão do nó com base em um recurso específico.
A impureza de Gini é outra medida usada para avaliar a qualidade de uma divisão. Ele quantifica a probabilidade de classificar incorretamente um ponto de dados escolhido aleatoriamente em um nó se atribuirmos um rótulo de classe com base na distribuição de rótulos de classe nesse nó. A impureza Gini de um nó é calculada usando a seguinte fórmula:
Gini(nó) = 1 - soma(p(i)^2), para todas as classes i
onde p(i) representa a proporção de pontos de dados no nó que pertencem à classe i. Semelhante à entropia, o valor de impureza de Gini varia de 0 a 1, onde 0 indica um nó puro e 1 indica impureza máxima.
Para avaliar a qualidade de uma divisão, calculamos a média ponderada dos valores de impureza Gini para os nós filhos resultantes. Isso é conhecido como índice de impureza de Gini. O índice de impureza de Gini é calculado da seguinte forma:
Gini Index = sum((|Sv| / |S|) * Gini(Sv)), para todos os nós filhos v
onde |Sv| representa o número de pontos de dados no nó filho v, e |S| é o número total de pontos de dados no nó pai. O índice de Gini mede a redução na impureza de Gini alcançada pela divisão do nó com base em um recurso específico.
Tanto a entropia quanto a impureza de Gini são comumente usadas em algoritmos de árvore de decisão, e a escolha entre elas depende do problema específico e das características dos dados. No scikit-learn, você pode selecionar o parâmetro de critério para especificar 'entropia' ou 'gini' ao criar modelos de árvore de decisão.
No próximo vídeo, aprofundaremos essas medidas e discutiremos como usá-las para determinar as melhores divisões em um algoritmo de árvore de decisão.
6.4 Critérios de divisão (L06: Árvores de Decisão)
6.4 Critérios de divisão (L06: Árvores de Decisão)
No vídeo, o palestrante investiga as complexidades das árvores de decisão e apresenta o conceito de critérios de divisão dentro dessa estrutura. Os critérios de divisão são essencialmente os critérios ou medidas empregados para determinar o recurso mais adequado para dividir um nó pai em seus nós filhos. Geralmente, um conjunto de dados abrange vários recursos, denotados como x1, x2, x3, ..., xm, onde j representa um valor que varia de 1 a m.
O palestrante enfatiza que em cada nó da árvore de decisão, uma decisão crítica deve ser tomada em relação ao recurso a ser utilizado para o processo de divisão. Para identificar o recurso ideal, determinados critérios ou medidas são definidos para comparar e avaliar os recursos disponíveis. O objetivo é selecionar um recurso que produza uma melhor divisão, aumentando assim a precisão preditiva da árvore de decisão.
Para ilustrar o funcionamento das árvores de decisão, o palestrante apresenta um conjunto de dados de brinquedo que consiste em três recursos: x1, x2, x3 e uma coluna que denota o rótulo da classe, y. Os rótulos de classe neste conjunto de dados são binários, assumindo os valores de uns ou zeros. O palestrante observa que, ao empregar apenas dois recursos, é possível atingir uma precisão de treinamento de 100% para esse conjunto de dados específico.
Desafiando o público, o palestrante pede que encontrem duas regras baseadas nos três recursos que podem levar a uma precisão de treinamento de 100%. Eles sugerem pausar o vídeo para contemplar a solução. Posteriormente, o palestrante revela a solução, explicando que apenas x1 e x2 são os recursos relevantes e úteis, enquanto x3 é aparentemente aleatório e não contribui para a precisão.
Seguindo em frente, o palestrante representa visualmente o conjunto de dados plotando os valores de x1 e x2 em um gráfico. Os pontos vermelhos no gráfico representam pontos de dados pertencentes ao rótulo de classe um, enquanto os quadrados azuis representam pontos de dados rotulados como zero. Com base no padrão observado nos pontos de dados, o locutor cria uma divisão, resultando na formação de uma árvore de decisão.
A divisão inicial é baseada em x1 sendo maior que 5,5. Essa divisão particiona os dados em duas regiões, uma rotulada como azul e a outra vermelha. O palestrante observa que, embora essa divisão classifique corretamente alguns pontos de dados, ela também classifica incorretamente outros. A divisão subsequente é baseada em x2 sendo maior que 10,5. Isso refina ainda mais o processo de classificação e, finalmente, leva a uma árvore de decisão que atinge 100% de precisão de treinamento.
Para aumentar a clareza, o alto-falante fornece uma representação visual mais clara da árvore de decisão, elucidando as informações associadas a cada nó. Cada nó simboliza um nó pai que sofre divisão, resultando na criação de nós filhos. Para cada nó, são exibidos o valor de divisão (representado pelo valor e limite do recurso), entropia (uma medida do conteúdo da informação), número de exemplos de treinamento (amostras), distribuição de rótulos de classe (local) e classe majoritária.
A árvore de decisão é representada em uma estrutura hierárquica, com nós pais dando origem a nós filhos. O palestrante destaca a importância de cada nó, destacando que as árvores de decisão empregam esses nós para fazer previsões com base nos recursos de entrada.
Por fim, o palestrante menciona uma abordagem alternativa para atingir 100% de precisão de treinamento utilizando apenas o recurso dois. Eles demonstram uma árvore de decisão com base nessa abordagem alternativa, mostrando como o recurso dois pode ser dividido nos valores 7,5 e 10 para segregar com precisão os pontos de dados nas classes desejadas.
Em um cenário ideal em que temos recursos contínuos e limites definidos corretamente, os conceitos mencionados acima se aplicariam. Em vez de usar a variável "V", empregaríamos uma variável xj, representando um recurso contínuo menor ou igual a um limite. O segundo nó filho simbolizaria valores maiores que o limite. Nesse caso, se possuímos recursos contínuos, uma fórmula semelhante à anterior pode ser empregada, mas agora precisamos incorporar um valor limite à função. Podemos comparar os valores para verificar se eles são maiores ou iguais ao limite.
Portanto, se tivermos um recurso contínuo e uma árvore binária semelhante ao CART (Árvore de Classificação e Regressão), precisamos apenas somar dois nós filhos em vez de múltiplos. Um nó filho corresponde a valores maiores que o limite, enquanto o outro representa valores menores ou iguais ao limite. Essa simplificação é lógica, pois nos concentramos nos dois resultados possíveis com base no valor limite. No entanto, é fundamental reconhecer que essa explicação pode parecer densa, e um aspecto significativo que ainda está faltando é o conceito de entropia, que será explorado nos próximos slides.
Nesse contexto, a entropia pertence à entropia de Shannon, introduzida por Claude Shannon no âmbito da teoria da informação. Diverge da entropia empregada em biofísica ou termodinâmica. A entropia de Shannon serve como uma métrica para quantificar a impureza ou desordem dos nós filhos nas árvores de decisão. Ele quantifica a quantidade de informação transmitida por uma variável aleatória discreta que possui dois resultados, semelhante a uma distribuição de Bernoulli. Na distribuição de Bernoulli, um parâmetro de probabilidade denotado como p representa a probabilidade de ocorrência de um evento.
Shannon definiu informação como o número de bits necessários para codificar o valor 1/p. Em termos mais simples, mede o nível de certeza ou incerteza associado a um evento. O número de bits necessários pode ser calculado como o logaritmo base 2 de 1/p. À medida que a probabilidade p aumenta, o número de bits necessários diminui, indicando um maior grau de certeza. Por outro lado, conforme a probabilidade se aproxima de zero, o número de bits necessários aumenta, implicando em um nível mais alto de incerteza.
Para exemplificar esse conceito, vamos considerar alguns exemplos. Se tivéssemos uma probabilidade de 0,5, o número de bits necessários seria 1. Se a probabilidade fosse 0, o número de bits necessários seria infinito, significando certeza absoluta. Por outro lado, se a probabilidade for 1, o número de bits necessários seria 0, indicando incerteza total. Portanto, a faixa de valores para o termo -log2(p) vai de menos infinito a 0.
A entropia de Shannon é calculada como a informação média em todos os eventos possíveis. Representa a média ponderada das informações associadas a cada evento, sendo os pesos as respectivas probabilidades dos eventos. No caso de árvores de decisão, o conceito de entropia pode ser aplicado para medir a impureza de um nó filho. Se um nó exibir uma distribuição bem balanceada de rótulos de classe, ele possuirá maior entropia, significando maior impureza. Por outro lado, se um nó exibe uma distribuição distorcida onde uma classe domina, ele possuirá menor entropia, indicando menor impureza. Essa noção se alinha intuitivamente, pois um nó com maior impureza fornece menos informações para fins de classificação.
A entropia oferece um meio de medir a impureza ou desordem dentro dos nós filhos das árvores de decisão. Ele permite a avaliação da pureza de um nó com base na distribuição de rótulos de classe. Um nó com maior entropia sugere uma distribuição mais diversa, enquanto um nó com menor entropia indica uma distribuição mais homogênea. Ao considerar a entropia dos nós filhos, decisões mais informadas podem ser tomadas ao construir árvores de decisão.
6.5 Gini & Entropia versus erro de classificação incorreta (L06: Árvores de Decisão)
6.5 Gini & Entropia versus erro de classificação incorreta (L06: Árvores de Decisão)
No vídeo anterior, discutimos os vários critérios de divisão que podem ser usados para desenvolver uma árvore de decisão. Agora, vamos investigar por que dois dos critérios de divisão, ou seja, impureza de Gini e entropia, são preferidos em relação ao terceiro critério, erro de classificação.
Para recapitular, temos três medidas de impureza: entropia, entropia escalonada (escalonada em 0,5 para comparação com a impureza de Gini) e erro de classificação incorreta. A forma dessas medidas de impurezas é diferente. A entropia aparece como uma função côncava, enquanto o erro de classificação tem um pico agudo em 0,5 com inclinações lineares.
Surge a pergunta: por que usamos entropia e impureza de Gini em vez de erro de classificação incorreta para o crescimento de árvores de decisão? Esta questão se aplica não apenas à entropia, mas também à impureza de Gini. Neste vídeo, vamos nos concentrar na entropia, mas o conceito também se aplica à impureza de Gini.
Vamos considerar a equação de ganho de informação. Temos uma função de impureza para o nó pai, que representa o conjunto de dados D no nó pai. Quando dividimos esse conjunto de dados com base em valores de recursos, geramos diferentes nós filhos. Esse conceito se aplica a feições categóricas e contínuas. Para recursos contínuos, podemos dividir criando compartimentos com base em um limite.
A medida de impureza é usada para os nós pai e filho, e nós os somamos considerando o tamanho do conjunto de dados original no nó pai e no nó filho atual. Geralmente, se escolhermos uma medida de impureza para o pai, também a mantemos consistente para os nós filhos.
Na prática, tendemos a evitar erros de classificação, pois há uma desvantagem, que discutiremos neste vídeo. Vamos rever brevemente como a entropia e o erro de classificação são calculados. A entropia é calculada somando o produto da proporção de rótulos para cada classe e o logaritmo da proporção. Por outro lado, o erro de classificação é baseado na perda 0/1, que mede a proporção de rótulos classificados incorretamente.
Agora, com foco na entropia versus erro de classificação incorreta, uma diferença fundamental são suas formas. A entropia é côncava, enquanto o erro de classificação não é. Essa diferença influencia por que a entropia é favorecida em relação ao erro de classificação incorreta para o crescimento das árvores de decisão.
Para ilustrar isso, vamos considerar um conjunto de dados de brinquedo simples. No nó pai, temos 40 exemplos de classe um e 80 exemplos de classe zero. Se dividirmos o conjunto de dados com base nos valores dos recursos, acabamos com nós filhos que possuem diferentes distribuições de classes. Precisamos avaliar se essa divisão melhora a pureza dos nós em comparação com o pai.
Se calcularmos a entropia para os nós pai e filho, descobrimos que a entropia para o nó filho dois é menor que a do pai, indicando maior pureza. No entanto, o nó filho um é pior que o pai. Em média, precisamos determinar se a divisão é benéfica.
Para medir a qualidade da divisão, usamos o ganho de informação, que considera os valores de entropia para os nós pai e filho. Se o ganho de informação for positivo, indica uma boa divisão. Em nosso exemplo, o ganho de informação é positivo, indicando uma divisão favorável com base na entropia.
Agora, vamos examinar o mesmo cenário usando erros de classificação. O erro para o pai, nó filho um e nó filho dois é calculado com base na proporção de rótulos classificados incorretamente. Se inserirmos esses valores de erro na fórmula de ganho de informação, descobriremos que o ganho de informação é zero. Um ganho de informação zero implica que a divisão não é benéfica. Consequentemente, esses nós não existirão e precisaríamos considerar outros recursos.
Em conclusão, a principal razão pela qual a entropia é preferida ao erro de classificação incorreta para árvores de decisão crescentes é que a entropia captura a incerteza e a desordem nos dados de forma mais eficaz. A forma côncava da entropia permite uma melhor diferenciação entre diferentes distribuições de classe e fornece uma medida mais sutil de impureza. Por outro lado, o erro de classificação incorreta é uma medida mais simplista que considera apenas a proporção de rótulos classificados incorretamente e não captura a incerteza e a distribuição das classes.
A forma côncava da entropia permite penalizar tanto os pequenos como os grandes desequilíbrios de classe. É sensível a mudanças nas proporções de classes, dando pesos maiores para classes distribuídas de forma mais uniforme. Essa propriedade torna a entropia particularmente útil ao lidar com conjuntos de dados que possuem distribuições de classes desequilibradas.
Em contraste, o erro de classificação incorreta tem uma forma linear, com um pico agudo em 0,5. Ele trata todos os erros de classificação igualmente e não distingue entre diferentes graus de erros de classificação. Isso torna o erro de classificação incorreta mais sensível a desequilíbrios de classe e menos eficaz em cenários com conjuntos de dados desequilibrados.
Além disso, a diferença nas formas entre a entropia e o erro de classificação afeta o processo de aprendizado da árvore de decisão. As árvores de decisão visam encontrar divisões que maximizem o ganho de informações ou diminuam a impureza. Como a entropia fornece uma medida de impureza mais refinada, ela permite que as árvores de decisão façam divisões mais informadas e precisas.
Ao usar a entropia como medida de impureza, as árvores de decisão são capazes de capturar relacionamentos complexos entre recursos e classes. Eles podem lidar com recursos contínuos e categóricos e podem descobrir padrões intrincados nos dados.
Em resumo, a entropia é preferível ao erro de classificação incorreta para o crescimento de árvores de decisão porque captura a incerteza e a desordem nos dados de forma mais eficaz. Sua forma côncava permite uma melhor diferenciação entre diferentes distribuições de classes e é mais robusta para conjuntos de dados desbalanceados. Ao usar a entropia, as árvores de decisão podem fazer divisões mais informadas e capturar relacionamentos complexos entre recursos e classes.
6.6 Melhorias e como lidar com overfitting (L06: Árvores de Decisão)
6.6 Melhorias e como lidar com overfitting (L06: Árvores de Decisão)
No vídeo anterior, discutimos os diferentes critérios de divisão que podem ser usados para desenvolver uma árvore de decisão. Agora, vamos nos aprofundar em por que dois dos critérios de divisão, ou seja, impureza de Gini e entropia, são preferidos sobre o terceiro critério, erro de classificação.
Para refrescar a memória, vamos relembrar os três critérios de divisão: entropia, entropia escalonada (para comparação com a impureza de Gini) e erro de classificação. A forma dessas medidas de impurezas pode ser visualizada da seguinte forma: a entropia é uma função côncava, representada por uma linha preta alta; a entropia escalonada também é côncava e é obtida multiplicando a entropia por 0,5; e o erro de classificação exibe um pico agudo em 0,5 e inclinações lineares.
Agora, surge a pergunta: por que preferimos usar entropia e impureza de Gini em vez do erro de classificação incorreta ao criar árvores de decisão? Essa questão se aplica tanto à entropia quanto à impureza de Gini, mas, para simplificar, vamos nos concentrar na entropia nesta discussão.
Vamos recapitular a equação de ganho de informação. Começamos com um nó pai, denotado como D, e dividimos esse conjunto de dados com base nos valores dos recursos, criando diferentes nós filhos. A função de impureza é usada para os nós pai e filho, e somamos os valores de impureza levando em consideração o tamanho dos conjuntos de dados. Se escolhermos entropia para o nó pai, também usaremos entropia para os nós filhos. O mesmo princípio se aplica à impureza de Gini.
Na prática, preferimos não usar o erro de classificação incorreta porque ele tem uma desvantagem, que exploraremos neste vídeo. Para entender isso melhor, vamos revisar brevemente as fórmulas para entropia, impureza de Gini e erro de classificação incorreta.
A entropia é calculada inserindo as proporções dos rótulos de classe e somando-os. Ele usa logaritmos e é representado pela fórmula onde somamos as classes e multiplicamos a proporção de cada classe pelo logaritmo dessa proporção.
A impureza de Gini, por outro lado, eleva ao quadrado a proporção do rótulo da classe e a subtrai de um. Ele evita o uso de logaritmos e é denotado como 1 menos a soma das proporções quadradas dos rótulos das classes.
O erro de classificação incorreta é baseado na perda de 0-1, que mede a proporção de rótulos classificados incorretamente. Por exemplo, se tivermos um nó com rótulos 001111, o voto da maioria prediz 0 porque é a classe majoritária. No entanto, considerando a distribuição, estaríamos corretos apenas quatro em seis vezes, resultando em uma precisão de 4/6 ou 66,6%. O erro seria 2/6 ou 33,3%.
Para comparar a entropia e o erro de classificação incorreta, observamos que a entropia é côncava, enquanto o erro de classificação exibe um pico agudo em 0,5 e inclinações lineares. Essa diferença é crucial para entender por que a entropia é preferida ao erro de classificação incorreta para o crescimento de árvores de decisão.
Para ilustrar isso, vamos considerar um conjunto de dados toy simples com um nó pai contendo 40 exemplos da classe um e 80 exemplos da classe zero. Assumindo que o melhor recurso para dividir é x1, dividimos o conjunto de dados com base em se os valores do recurso são um ou zero. Obtemos dois nós filhos: nó filho um e nó filho dois. Ao analisar a distribuição de classes, descobrimos que o nó filho dois é mais puro que o pai, enquanto o nó filho um é pior.
A questão-chave é se vale a pena dividir esse recurso ou não. Para determinar isso, calculamos o ganho de informação usando entropia. Calculamos os valores de entropia para o nó pai, nó filho um e nó filho dois. Comparando esses valores, observamos que o nó filho dois é melhor, enquanto o nó filho um é pior que o pai. Aplicando a fórmula de ganho de informação, descobrimos que o ganho de informação para esta divisão é positivo, indicando que a divisão melhora a pureza geral do conjunto de dados.
Agora, vamos considerar o erro de classificação incorreta como medida de impureza em vez de entropia. Calculamos o erro de classificação incorreta para o nó pai, nó filho um e nó filho dois. Comparando esses valores, descobrimos que o nó filho dois tem um erro de classificação menor do que o pai, enquanto o nó filho um tem um erro de classificação maior.
No entanto, quando calculamos o ganho de informação usando o erro de classificação incorreta, encontramos um problema. A fórmula de ganho de informação envolve a subtração dos erros de classificação ponderados dos nós filhos do erro de classificação incorreta do pai. Como o erro de classificação é uma função linear, o ganho de informação pode ser negativo se o erro de classificação dos nós filhos for maior que o do pai.
Em nosso exemplo, embora o nó filho dois tenha um erro de classificação menor do que o pai, o erro de classificação do nó filho um é maior, resultando em um ganho de informação negativo. Isso significa que usar o erro de classificação incorreta como medida de impureza desencorajaria a divisão, embora melhore a pureza de um dos nós filhos.
Por outro lado, quando usamos entropia ou impureza de Gini como medidas de impureza, o ganho de informação será sempre não negativo. Tanto a entropia quanto a impureza de Gini são funções côncavas, o que significa que os valores de impureza dos nós filhos são sempre menores ou iguais ao valor de impureza do nó pai. Isso garante que o ganho de informação será positivo sempre que a divisão melhorar a pureza de pelo menos um nó filho.
Ao usar entropia ou impureza de Gini como medidas de impureza, as árvores de decisão podem fazer divisões com base no ganho de informações, o que fornece uma abordagem baseada em princípios para aumentar a árvore e melhorar seu poder preditivo. O erro de classificação incorreta, por outro lado, pode levar a divisões abaixo do ideal e árvores de decisão menos precisas.
Em resumo, a preferência por entropia e impureza de Gini em vez de erro de classificação incorreta em algoritmos de árvore de decisão está enraizada em suas propriedades matemáticas. A natureza côncava da entropia e da impureza de Gini garante que o ganho de informação será positivo para divisões que melhoram a pureza dos nós filhos, enquanto a natureza linear do erro de classificação incorreta pode resultar em ganhos de informação negativos e divisões abaixo do ideal.
6.7 Exemplo de código implementando árvores de decisão no Scikit-Learn (L06: Árvores de decisão)
6.7 Exemplo de código implementando árvores de decisão no Scikit-Learn (L06: Árvores de decisão)
Para concluir a aula seis, examinaremos agora um exemplo de código usando o scikit-learn, focando especificamente no algoritmo da árvore de decisão. O Scikit-learn é recomendado para projetos de aprendizado de máquina do mundo real devido à sua velocidade, eficiência e robustez. Embora usemos o scikit-learn para esta demonstração, vale a pena mencionar que você implementará uma árvore de decisão desde o início para a tarefa de casa para aprimorar sua compreensão do algoritmo.
Para começar, vamos importar os pacotes necessários, incluindo o pacote de marca d'água, que nos ajudará a rastrear as versões do software que está sendo usado. Isso pode ser útil caso surja algum problema ao executar o código devido a versões de software desatualizadas. Em seguida, carregamos o conjunto de dados da íris, um conjunto de dados popular frequentemente usado para tarefas de classificação. Ao usar um conjunto de dados conhecido como o iris, podemos nos concentrar mais em entender o código e sua funcionalidade, em vez de explicar os dados.
Dividimos o conjunto de dados em conjuntos de treinamento e teste, com 30% dos dados alocados para teste. É importante observar que não realizaremos nenhum ajuste neste notebook. Embora seja possível ajustar os hiperparâmetros da árvore de decisão usando técnicas como pesquisa em grade, vamos simplificar e pular o ajuste por enquanto. Portanto, não precisamos de um conjunto de validação separado, pois treinaremos a árvore de decisão apenas no conjunto de treinamento e avaliaremos seu desempenho no conjunto de teste.
Passando a plotar as regiões de decisão, inicializamos o classificador da árvore de decisão e definimos os hiperparâmetros. Nesse caso, escolhemos o critério de entropia para ganho de informação e definimos a profundidade máxima para dois para fins educacionais. Além disso, ajustamos a árvore de decisão aos dados de treinamento e plotamos as regiões de decisão. Ao visualizar as regiões de decisão, podemos observar como a árvore de decisão separa os dados com base nas características selecionadas.
Exploramos diferentes opções e hiperparâmetros que podem ser definidos para o classificador da árvore de decisão. Isso inclui o divisor, que determina como as divisões são feitas em cada nó e os parâmetros relacionados às amostras mínimas necessárias para dividir nós e nós folha. Também existem opções para selecionar a medida de impureza e controlar a aleatoriedade das divisões. Esses hiperparâmetros podem ser ajustados e ajustados com base no problema e no conjunto de dados específicos.
Em seguida, passamos a visualizar a árvore de decisão usando a biblioteca graphviz. Exportamos a árvore de decisão como um arquivo de pontos, que representa a estrutura da árvore como um gráfico. Podemos personalizar a aparência dos nós, arestas e rótulos no gráfico. Ao usar a biblioteca graphviz em conjunto com a biblioteca pydotplus, podemos plotar a árvore de decisão diretamente sem salvar o arquivo ponto separadamente. Dessa forma, podemos visualizar a árvore de decisão dentro do próprio notebook.
Para exibir o gráfico da árvore de decisão, carregamos o arquivo PNG gerado usando o módulo de exibição ipython. Importamos a classe de imagem do ipython display e a usamos para carregar o arquivo PNG. Isso nos permite visualizar o gráfico da árvore de decisão diretamente no Jupyter Notebook. O gráfico da árvore de decisão mostra as divisões e os limites de decisão como linhas verticais e horizontais, respectivamente, com base nos recursos selecionados.
Em resumo, este exemplo de código demonstra como implementar e visualizar um classificador de árvore de decisão usando o scikit-learn. O algoritmo da árvore de decisão fornece um modelo interpretável para tarefas de classificação e pode ser ajustado usando vários hiperparâmetros para melhorar o desempenho. A visualização da árvore de decisão ajuda a entender como o algoritmo toma decisões com base nos recursos de entrada.
7.1 Introdução aos métodos ensemble (L07: Métodos ensemble)
7.1 Introdução aos métodos ensemble (L07: Métodos ensemble)
Na palestra desta semana, vamos nos aprofundar nos métodos de ensemble, que são um campo crucial no aprendizado de máquina. Esses métodos são amplamente utilizados na pesquisa aplicada de aprendizado de máquina para obter alto desempenho em aplicativos do mundo real. Métodos sólidos, que são conhecidos por sua eficácia na prática, geralmente produzem os melhores resultados.
A palestra também revisitará as árvores de decisão, abordando algumas questões levantadas na Piazza sobre sua relevância. Apesar de ser um algoritmo relativamente antigo e familiar, as árvores de decisão permanecem altamente relevantes hoje. Eles não são apenas interpretáveis, mas são frequentemente empregados em métodos de conjunto, onde exibem um desempenho excepcional. A palestra também pretende explorar esse aspecto.
Antes de nos aprofundarmos nos métodos de conjunto, é importante recapitular nossa posição no semestre. No momento, estamos concluindo a parte três, que se concentra nos métodos baseados em árvore. No entanto, vale a pena notar que alguns desses métodos vão além das árvores de decisão e abrangem outras técnicas, incluindo métodos sólidos aplicados a redes neurais profundas. As árvores de decisão foram categorizadas na parte três devido à sua estreita associação com a maioria dos métodos de conjunto.
Depois de concluir esta seção, vamos nos aprofundar na avaliação do modelo antes de discutir o aprendizado não supervisionado e, se o tempo permitir, o aprendizado bayesiano. Embora o plano inicial fosse fazer o exame intermediário e cobrir outros métodos mais cedo, a progressão do curso demorou mais do que o previsto. No entanto, o tempo adicional gasto na configuração do ambiente Python e na familiarização de todos, especialmente aqueles sem uma sólida experiência em Python, foi benéfico. Ele garante que todos os participantes estejam na mesma página e preparados para o próximo dever de casa, que envolverá a implementação de uma árvore de decisão CART (Classification and Regression Trees) sem depender de bibliotecas pré-construídas como o scikit-learn.
A palestra está estruturada em sete partes. A primeira parte fornece uma introdução e visão geral dos métodos ensemble. Posteriormente, exploraremos vários métodos internos, começando com a votação por maioria, o tipo mais simples de método ensemble. Em seguida, nos aprofundaremos no bagging, uma técnica que envolve amostragem bootstrap do conjunto de treinamento. A utilidade deste método será explicada. O reforço, que envolve transformar alunos fracos (como árvores de decisão curtas) em modelos fortes, também será abordado. Em particular, discutiremos o aumento de gradiente, um dos algoritmos mais populares da atualidade, conhecido por seu sucesso nas competições do Kaggle. Florestas aleatórias, outro método de conjunto amplamente reconhecido, serão introduzidas. Esses modelos são conhecidos por sua facilidade de uso, pois geralmente oferecem excelente desempenho sem ajuste extensivo de hiperparâmetros. Eles são recomendados para indivíduos que buscam modelos preditivos em vários campos científicos, especialmente se não tiverem experiência em aprendizado de máquina.
Máquinas de vetores de suporte (SVM) também serão mencionadas, particularmente sua popularidade no passado devido ao seu desempenho, especialmente com kernels RBF (Radial Basis Function). No entanto, as florestas aleatórias geralmente fornecem resultados igualmente bons ou melhores sem a necessidade de ajustes extensivos, tornando-as preferíveis para aplicações práticas. Por fim, será discutido o empilhamento, outra técnica popular em aplicações.
Para ilustrar a importância dos métodos ensemble, uma figura será apresentada, mostrando um exemplo envolvendo florestas aleatórias. Este modelo não se limita a tarefas de classificação e pode facilmente calcular a importância do recurso. Por exemplo, no exemplo mencionado, os átomos de enxofre foram identificados como as características mais importantes para prever a atividade das moléculas. Esses insights podem ser valiosos na prática.
Além disso, métodos de conjunto, incluindo florestas aleatórias e aumento de gradiente, estão entre os modelos de aprendizado de máquina não profundos mais amplamente usados. Embora o aprendizado profundo esteja ganhando destaque, os ensembles ainda são altamente relevantes devido ao seu excelente desempenho e facilidade de implementação. O artigo mencionou o aumento do aumento de gradiente extremo (XGBoost) como a "nova rainha" em algoritmos de aprendizado de máquina. Isso ressalta a importância dos modelos baseados em árvore, particularmente o aumento de gradiente, em várias aplicações.
Em resumo, a palestra desta semana fornecerá uma compreensão abrangente dos métodos ensemble. Ele cobrirá diferentes tipos de técnicas de ensemble e suas aplicações.