Aprendizado de máquina e redes neurais - página 43

[MetaQuotes]

Como implementar o KNN do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/01%20KNN

Como implementar o KNN do zero com Python

No vídeo intitulado "Como implementar KNN do zero com Python", o palestrante explica como criar um classificador KNN do zero usando Python. Eles cobrem as etapas envolvidas na implementação do algoritmo, como calcular a distância entre o novo ponto de dados e outros pontos no conjunto de dados, selecionar os k pontos mais próximos e determinar o rótulo para classificação ou média para regressão. O palestrante implementa o algoritmo usando uma classe em Python e demonstra sua implementação bem-sucedida no conjunto de dados da íris com uma taxa de precisão de 96%. Eles também convidam os espectadores a verificar o código em seu repositório Github e fazer perguntas na seção de comentários.

• 00:00:00 Nesta seção, aprenderemos sobre o algoritmo k Nearest Neighbours (k-NN), como ele funciona e as etapas necessárias para implementar o algoritmo em Python. k-NN é um algoritmo baseado em distância em que os k pontos de dados mais próximos são selecionados com base em sua distância até o novo ponto de dados. Este valor de k é determinado pelo usuário e pode ser usado para problemas de regressão e classificação. O algoritmo começa calculando a distância entre o novo ponto de dados e outros pontos de dados no conjunto de dados. Então, os k pontos mais próximos são escolhidos e a média de seus valores é tomada para regressão, ou o rótulo com a maioria dos votos é determinado para classificação. Também vemos como implementar o algoritmo usando uma classe em Python com uma função de ajuste e previsão e uma função auxiliar para calcular a distância entre dois pontos.
  
  
• 00:05:00 Nesta seção, o palestrante explica como criar um classificador KNN do zero usando Python. Começando com o método arc sort para classificar a matriz de distância, eles passam a selecionar os k vizinhos mais próximos, obtendo o rótulo de classe mais comum e retornando o rótulo mais comum. Eles então implementam esse classificador no conjunto de dados da íris para classificar os tipos de flores e atingem uma taxa de precisão de 96%, demonstrando a implementação bem-sucedida do KNN. O palestrante convida os espectadores a verificar o código disponível em seu repositório Github e fazer perguntas na seção de comentários.

[MetaQuotes]

Como implementar a regressão linear do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/02%20Linear%20Regression

Como implementar a regressão linear do zero com Python

Este vídeo aborda o processo de implementação de regressão linear do zero usando Python. O palestrante explica como encontrar a melhor linha de ajuste usando o erro quadrático médio e como calcular os pesos e vieses com a descida do gradiente. O palestrante também discute como a taxa de aprendizado afeta a convergência e demonstra como testar o modelo usando o recurso de conjunto de dados do scikit-learn. Eles também corrigem um erro de digitação no código e ajustam a taxa de aprendizado para melhorar o ajuste da linha de previsão. O código é compartilhado no GitHub e os espectadores são convidados a fazer perguntas.

• 00:00:00 Nesta seção, o foco está na regressão linear, que envolve entender o padrão de um determinado conjunto de dados e desenhar uma linha linear que se ajuste aos dados da melhor maneira possível. O erro quadrático médio é usado para calcular o erro da linha para todos os pontos de dados, e a melhor linha de ajuste é encontrada calculando os valores para os parâmetros do modelo ou peso e viés que fornecem o erro quadrático médio mínimo usando a descida do gradiente. A taxa de aprendizado é usada para controlar o quão rápido ou lento ir na direção que a descida do gradiente nos diz para ir, onde uma baixa taxa de aprendizado pode causar uma aproximação lenta ao erro mínimo, enquanto uma alta taxa de aprendizado pode resultar em saltos no espaço aéreo. e falha em encontrar o mínimo. Durante o treinamento, o peso e o viés são inicializados como zero e a equação recebe um ponto de dados para prever ou estimar
  o resultado e o erro da equação é calculado, facilitando o uso da multiplicação de matrizes com todos os pontos de dados para calcular os gradientes. Durante o teste, um modelo treinado prevê resultados usando a equação.
  
  
• 00:05:00 Nesta seção, o palestrante está implementando regressão linear do zero com Python. O alto-falante inicializa a taxa de aprendizado, define um valor padrão para o número de iterações e define os pesos e desvios como zero. O orador então prossegue para prever o resultado tomando o produto escalar de x com os pesos e adicionando o viés. Para calcular as derivadas, o palestrante usa uma equação simples e, em seguida, atualiza os pesos e vieses calculando os gradientes. Finalmente, o locutor soma as diferenças entre as previsões e os valores reais, e o processo é repetido por várias iterações até a convergência.
  
  
• 00:10:00 Nesta seção, o palestrante discute como treinar o modelo de regressão linear e fazer previsões usando a classe fornecida. A atualização dos pesos e bias é feita subtraindo a taxa de aprendizado vezes as derivadas dos pesos e bias respectivamente. Para fazer várias iterações de execução do algoritmo, um loop for é adicionado para executar o algoritmo sobre o conjunto de dados. Por fim, o palestrante mostra como testar a eficiência do algoritmo de regressão linear usando um recurso de conjunto de dados do scikit-learn, ajustando uma linha que resulta em bom desempenho e calculando o erro quadrático médio para as previsões. Um erro de dimensão é encontrado devido ao cálculo incorreto do produto escalar, que é corrigido obtendo a transposição de x.
  
  
• 00:15:00 Nesta seção, o apresentador corrige um erro de digitação no código e o usa para criar um modelo de regressão linear que prevê os valores y com base nos valores x de um determinado conjunto de dados. Eles então visualizam a linha de previsão e percebem que, embora ela se encaixe bem, ela pode ser melhorada. O apresentador decide ajustar a taxa de aprendizado e reexecuta o modelo para obter um melhor ajuste. Eles compartilham o código no GitHub e convidam os espectadores a fazer perguntas, se necessário.

[MetaQuotes]

Como implementar a regressão logística do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/03%20Logistic%20Regression

Como implementar a regressão logística do zero com Python

O vídeo explica como implementar a regressão logística do zero com Python, usando a função sigmoide para criar probabilidades e entropia cruzada como uma função de erro. O instrutor compartilha instruções passo a passo para calcular previsões, gradientes e tendências de atualização por meio de iterações. Eles também demonstram como carregar um conjunto de dados de câncer de mama e treinar o classificador de regressão logística para prever se um tumor é maligno ou benigno. O vídeo termina avaliando a precisão do modelo usando uma função personalizada. No geral, a implementação é bem-sucedida e prova que o algoritmo de regressão logística funciona bem.

• 00:00:00 Nesta seção, o vídeo discute a regressão logística e como ela envolve a criação de probabilidades em vez de valores específicos usando a função sigmoide. Em vez de usar o erro quadrático médio, a regressão logística usa entropia cruzada para sua função de erro. Para usar o gradiente descendente, o gradiente da função de erro em termos de peso e viés precisa ser calculado. A taxa de aprendizado é usada para determinar o quão rápido se aproxima da direção dada pelo gradiente. Durante o teste, a probabilidade é calculada e o rótulo é escolhido com base na probabilidade mais alta. A implementação da regressão logística é semelhante à regressão linear, mas com a inicialização dos pesos e bias como zero.
  
  
• 00:05:00 Nesta seção do vídeo, o instrutor explica como implementar a regressão logística com Python usando uma função sigmoide para prever os resultados. O processo envolve o cálculo das previsões a partir do produto dos pesos e dos valores x mais o viés, colocando-os em uma função sigmoide para fornecer os resultados e calculando os gradientes. O instrutor demonstra como calcular o gradiente para o viés e atualizações por meio de iterações. A seção também inclui como realizar inferência com regressão logística obtendo a probabilidade e escolhendo o rótulo com base nos valores das previsões.
  
  
• 00:10:00 Nesta seção, o instrutor demonstra como implementar a regressão logística do zero usando Python. Eles explicam o processo passo a passo, mostrando como calcular probabilidades e rótulos de classes usando a função sigmoide, e como ajustar a taxa de aprendizado para obter melhores resultados. O instrutor também carrega um conjunto de dados de câncer de mama do Scikit-learn e treina o classificador de regressão logística para prever se um tumor é maligno ou benigno com base nos recursos do conjunto de dados. Por fim, eles avaliam a precisão do algoritmo e demonstram como calculá-lo usando uma função personalizada. No geral, a implementação é bem-sucedida e mostra que o algoritmo caseiro funciona muito bem.

[MetaQuotes]

Como implementar árvores de decisão do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/04%20Decision%20Trees

Como implementar árvores de decisão do zero com Python

O vídeo fornece um guia passo a passo sobre como criar uma árvore de decisão do zero usando Python. O palestrante explica o conceito de árvores de decisão, como elas funcionam e como são construídas. Eles discutem os critérios de parada, a função de crescimento da árvore, as funções auxiliares "rótulo mais comum", "ganho de informação", "entropia" e "divisão", bem como a função de previsão. O palestrante também demonstra como calcular o ganho de informações, entropia ponderada e precisão. Além disso, eles testam o modelo de árvore de decisão e fornecem aos visualizadores um link para o repositório GitHub onde o código está disponível.

• 00:00:00 Nesta seção, aprendemos sobre árvores de decisão, como elas funcionam e como são construídas. As árvores de decisão são construídas para representar um conjunto de dados, com cada ponto de dados sendo dividido em nós de folha que representam 'sim' ou 'não'. Os nós entre os nós folha são chamados de ramificações e são divididos com base em recursos como recursos que mostram se o ponto de dados está localizado na vizinhança leste ou oeste. O ganho de informação é calculado como a entropia do pai e a média ponderada da entropia dos filhos, e o modelo de árvore de decisão é treinado com base nos ganhos de informação mais significativos. Por fim, discutimos os critérios de parada, que são usados para decidir quando parar de construir a árvore de decisão.
  
  
• 00:05:00 Nesta seção, o palestrante discute maneiras de parar uma árvore de decisão antes de analisar todos os nós de folha possíveis, incluindo a definição de uma profundidade máxima ou número mínimo de amostras para um nó ter. O palestrante então apresenta duas classes que serão utilizadas para a implementação da árvore de decisão: uma classe Node e uma classe DecisionTree. A classe Node inclui informações sobre o recurso com o qual o nó foi dividido e o valor do nó. A classe DecisionTree inclui métodos para ajustar a árvore com valores x e y, prever novos dados e definir critérios de parada como número mínimo de amostras e profundidade máxima. No geral, o palestrante faz uma abordagem passo a passo para delinear a implementação de uma árvore de decisão do zero em Python.
  
  
• 00:10:00 Nesta seção, o palestrante discute a implementação da função grow tree, que é a principal função que constrói a árvore de decisão recursivamente. A função recebe os valores x e y e verifica se o número de feições não excede o número de feições reais. A função primeiro verifica os critérios de parada e, em seguida, prossegue para encontrar a melhor divisão, criar nós filhos e chamar a função de crescimento da árvore novamente. Se os critérios de parada forem atendidos, a função cria um novo nó folha e o retorna com o parâmetro value. O palestrante também discute uma função auxiliar chamada "rótulo mais comum", que utiliza a estrutura de dados do contador e retorna o rótulo mais comum no conjunto de dados.
  
  
• 00:15:00 Nesta seção, o vídeo discute como implementar árvores de decisão do zero com Python. O instrutor demonstra como criar uma função auxiliar para encontrar o melhor limite e recurso para criar uma nova divisão. Esta função usa numpy para selecionar aleatoriamente um grupo de recursos para considerar a criação de uma nova divisão. Depois que a função auxiliar encontra o limite entre todas as divisões possíveis, ela calcula o ganho de informação para determinar se é melhor do que o melhor ganho calculado até agora. Por fim, o melhor índice e limite de divisão são retornados.
  
  
• 00:20:00 Nesta seção do vídeo, o palestrante cria uma função auxiliar chamada "ganho de informação" para calcular o ganho de informação e define outra função auxiliar chamada "entropia" para calcular a entropia do pai com base nos valores passados em . Eles explicam que a entropia do pai é calculada como a soma de px vezes log 2 de px e usam um truque numpy para contar as ocorrências de cada valor e dividi-lo pelo número total de valores para obter o p de x . Em seguida, o falante cria outra função auxiliar chamada "split" para ajudar a descobrir quais índices vão para a esquerda e quais vão para a direita e demonstra como o numpy argwhere funciona.
  
  
• 00:25:00 Nesta seção do vídeo, o apresentador explica como calcular a entropia ponderada dos filhos de uma árvore de decisão usando Python. Após obter o comprimento dos valores y e os índices esquerdo e direito, a entropia dos filhos pode ser calculada usando a fórmula da média ponderada. Isso envolve encontrar o número de amostras em cada nó filho dividido pelo número total de amostras, multiplicando-o pela entropia de cada nó e, em seguida, somando os resultados para obter a entropia dos filhos. Com essas informações, o ganho de informação pode ser calculado tomando a entropia pai menos a entropia filho, que é então passada de volta para toda a árvore de decisão.
  
  
• 00:30:00 Nesta seção do vídeo, o apresentador explica como implementar a função de previsão para o classificador de árvore de decisão. A função auxiliar traverse_tree é utilizada aqui para percorrer recursivamente a árvore e retornar o valor do nó folha se for alcançado. Se o valor da feição for menor ou igual ao limiar, o lado esquerdo da árvore é passado para ser percorrido, e o lado direito da árvore é passado para ser percorrido caso contrário. Os valores são retornados e, em seguida, transformados em um array numpy antes de serem gerados. O classificador da árvore de decisão é então testado com o conjunto de dados de câncer de mama e a função de previsão é usada para gerar previsões que são passadas para uma métrica de precisão.
  
  
• 00:35:00 Nesta seção, o apresentador está testando o modelo de árvore de decisão que construiu do zero usando Python. Eles primeiro calculam a precisão do modelo usando as previsões e os dados de teste. Eles também encontram dois erros no código - um na inicialização do nó e outro na função de árvore transversal. Depois de corrigir os erros, eles executam os dados de teste novamente e obtêm uma precisão de 0,91. Eles então passam argumentos diferentes ao modelo e obtêm uma precisão um pouco melhor. Por fim, o apresentador convida os espectadores a fazer perguntas e fornece um link para seu repositório GitHub, onde o código está disponível.

[MetaQuotes]

Como implementar Random Forest do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/05%20Random%20Forests

Como implementar Random Forest do zero com Python

Este tutorial em vídeo ensina como implementar Random Forests do zero com Python. Durante o treinamento, um subconjunto aleatório do conjunto de dados é selecionado e uma árvore de decisão é criada com esse subconjunto. Este processo é repetido para o número de árvores determinado antes de iniciar o algoritmo. Durante a inferência, a predição é obtida de cada árvore e, se for classificação, é obtido o voto majoritário do rótulo da classe. O palestrante demonstra como implementá-lo criando uma lista espalhando as árvores de decisão nela e adicionando-a a um array Numpy. A precisão pode ser calculada usando o número de valores verdadeiros previstos corretamente dividido pelo número total de valores verdadeiros. O palestrante também fala sobre o número de árvores, profundidade máxima e divisão mínima da amostra que podem ser modificados para obter maior precisão.

• 00:00:00 Nesta seção, aprenderemos sobre florestas aleatórias, que consistem em muitas árvores de decisão diferentes. O processo envolve a introdução de alguma aleatoriedade na equação ao criar essas árvores. Durante o treinamento, um subconjunto aleatório do conjunto de dados é selecionado e uma árvore de decisão é criada com esse subconjunto. Este processo é repetido para o número de árvores determinado antes de iniciar o algoritmo. Durante a inferência, a predição é obtida de cada árvore, e se for uma classificação, o voto majoritário do rótulo da classe é obtido. Se for regressão, a média de todas as previsões é calculada. A implementação usa a classe de árvores de decisão criada na lição anterior e é inicializada especificando o número de árvores, profundidade máxima, amostras mínimas para uma divisão, o número de recursos e uma matriz vazia para conter todas as árvores. uma função de ajuste e previsão, e o que é necessário é passar os parâmetros necessários conforme mencionado acima.
  
  
• 00:05:00 Nesta seção, o instrutor explica como ajustar uma árvore de decisão com base em um subconjunto de amostras e anexá-la à lista de árvores em um modelo de floresta aleatório. Uma função auxiliar "bootstrap_samples" é criada para escolher aleatoriamente um número especificado de amostras com substituição do conjunto de dados fornecido. O instrutor então explica como prever usando a floresta aleatória para uma entrada X, o que envolve iterar todas as árvores na floresta aleatória e retornar uma lista de previsões, onde cada lista interna contém previsões para a mesma amostra de árvores diferentes. Por fim, o instrutor apresenta a função "swap axis" do numpy para reorganizar as listas e uma função auxiliar "most_common" que usa a estrutura de dados do contador da biblioteca de coleções para retornar o rótulo de classificação mais comum.
  
  
• 00:10:00 Nesta seção, o palestrante explica o processo de implementação de uma floresta aleatória do zero usando Python. Eles mencionam uma função auxiliar que será usada para previsão e criam uma lista, espalhando as árvores de decisão nela e adicionando-a a um array NumPy que será retornado para previsões. A precisão é calculada usando o número de valores verdadeiros previstos corretamente dividido pelo número total de valores verdadeiros. O palestrante também menciona que o número de árvores, a profundidade máxima e a divisão mínima da amostra podem ser manipulados para obter maior precisão. O palestrante direciona os espectadores para o código em seu repositório GitHub e recebe perguntas na seção de comentários. Por fim, o orador passa a palavra a Patrick para a parte restante do tutorial.

[MetaQuotes]

Como implementar Naive Bayes do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/06%20NaiveBayes

Como implementar Naive Bayes do zero com Python

Este tutorial em vídeo se concentra na implementação do Naive Bayes do zero usando Python. O instrutor fornece uma visão geral do teorema de Bayes e a suposição de independência. Eles explicam como calcular a probabilidade anterior e a probabilidade condicional de classe, necessária para treinar o algoritmo. O palestrante também apresenta a distribuição gaussiana como uma forma de modelar probabilidades. O vídeo demonstra as etapas de treinamento e previsão do algoritmo com código. O instrutor testa o algoritmo em um conjunto de dados de brinquedo com duas classes, obtendo uma precisão de 96,5%. No geral, este tutorial é um recurso útil para os interessados em aprender Naive Bayes e implementá-lo em Python.

• 00:00:00 Nesta seção, o palestrante discute a teoria por trás do Naive Bayes, um classificador probabilístico que assume independência entre recursos para prever rótulos de classes. Eles explicam o teorema de Bayes e a suposição de independência, e como isso é usado para calcular a probabilidade posterior de cada classe. O palestrante continua explicando como calcular a probabilidade anterior e a probabilidade condicional de classe, ambas necessárias para o treinamento do algoritmo. Eles também introduzem a distribuição gaussiana como uma forma de modelar probabilidades. As etapas de treinamento e predição são resumidas e o código para implementar o Naive Bayes é demonstrado. O palestrante fornece uma definição para os métodos de ajuste e previsão e descreve as etapas necessárias para treinamento e previsão em cada um.
  
  
• 00:05:00 Nesta seção do vídeo, o instrutor explica como implementar Naive Bayes do zero usando Python. O código assume que x e y já estão no formato de matriz numpy e d. O instrutor mostra como extrair x usando x.shape e como obter o número de classes exclusivas usando numpy.unique(). O próximo passo é calcular a média, a variância e o prior para cada classe. Isso pode ser feito inicializando esses valores com zeros e calculando-os usando funções numpy. O instrutor então explica como calcular a probabilidade posterior para cada classe usando uma função auxiliar e uma compreensão de lista. Por fim, o instrutor mostra como retornar a previsão como uma matriz numpy.
  
  
• 00:10:00 Nesta seção, o palestrante discute a implementação do algoritmo Naive Bayes em Python. Eles passam pelas etapas de cálculo a priori, depois calculam a posteriori usando uma distribuição gaussiana e criam uma função auxiliar para a densidade de probabilidade, seguida pela previsão da classe com a posterior mais alta. Por fim, eles testaram o algoritmo em um conjunto de dados de brinquedo com 1.000 amostras e 10 recursos com duas classes, obtendo uma precisão de 96,5%. O palestrante incentiva uma exploração mais aprofundada do código e aguarda a próxima lição.

[MetaQuotes]

Como implementar PCA (Principal Component Analysis) do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/07%20PCA

Como implementar PCA (Principal Component Analysis) do zero com Python

O vídeo explica o processo de implementação do Principal Component Analysis (PCA) do zero usando Python e Numpy. PCA é uma técnica que reduz a dimensionalidade de um conjunto de dados, mantendo a maior parte da informação. O instrutor percorre as etapas de criação de uma classe Python com métodos de ajuste e transformação para executar o PCA em um conjunto de dados. O método de ajuste primeiro calcula a média e a covariância dos dados e extrai os autovetores e autovalores. O método transform então projeta os dados nos componentes principais. O palestrante destaca a importância de subtrair médias e ordenar autovetores no processo. Por fim, a implementação é testada no conjunto de dados Iris, resultando em uma redução bem-sucedida da dimensionalidade de quatro para duas dimensões.

• 00:00:00 Nesta seção, o instrutor discute a Análise de Componentes Principais (PCA), um método de aprendizado não supervisionado que reduz a dimensionalidade de um conjunto de dados transformando-o em um conjunto dimensional inferior que ainda contém a maior parte das informações do conjunto maior. O instrutor explica como o PCA encontra uma transformação de modo que os recursos transformados sejam linearmente independentes, com a dimensionalidade reduzida ao considerar apenas as dimensões com maior importância. As dimensões recém-encontradas devem minimizar o erro de projeção e os pontos projetados devem ter dispersão máxima, o que significa variação máxima. O instrutor percorre as etapas para implementar o PCA do zero usando Python e Numpy. Essas etapas incluem subtrair a média de x, calcular a covariância de x e x e classificar os autovetores de acordo com seus autovalores em ordem decrescente.
  
  
• 00:05:00 Nesta seção, o palestrante explica a implementação da análise de componentes principais (PCA) usando Python. Isso envolve a criação de uma função 'init' que recebe o número de componentes como entrada, um método 'fit' que subtrai a média, calcula a covariância, classifica os autovetores e armazena os componentes principais. O método 'transform' então aplica essa transformação a novos dados. O palestrante percorre cada etapa do código, destacando a importância de subtrair meios e classificar autovetores e, finalmente, produzir componentes principais para redução de dimensionalidade.
  
  
• 00:10:00 Nesta seção, o palestrante demonstra como implementar PCA (Principal Component Analysis) do zero em Python. Eles começam criando uma classe com um método de ajuste e transformação. O método de ajuste primeiro calcula a média dos dados e os centraliza em torno da média. Em seguida, calcula as covariâncias dos dados e extrai os autovetores e autovalores. O método transform então projeta os dados nos componentes principais com um produto escalar. Por fim, o palestrante testa a implementação com o conjunto de dados Iris e reduz com sucesso a dimensionalidade dos dados de quatro para duas dimensões.

[MetaQuotes]

Como implementar Perceptron do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/08%20Perceptron

Como implementar Perceptron do zero com Python

O tutorial em vídeo explica a teoria por trás do algoritmo Perceptron, que pode aprender apenas padrões linearmente separáveis para classificação binária usando uma função de ativação, pesos e entrada. O apresentador descreve as etapas necessárias para implementar o modelo Perceptron do zero em Python, selecionando a taxa de aprendizado e o número de iterações para o algoritmo de otimização e definindo a função de ativação como a função degrau unitário. Depois de inicializar os pesos e vieses, o modelo aprende com os dados de treinamento atualizando os pesos e vieses de acordo com a regra de atualização do Perceptron. Por fim, o apresentador avalia a precisão do modelo prevendo os rótulos de classe para os dados de teste, e a precisão é de 100%, indicando o aprendizado bem-sucedido do limite de decisão.

• 00:00:00 Nesta seção, o apresentador explica a teoria básica por trás do algoritmo Perceptron e como ele é um algoritmo para aprendizado supervisionado de classificadores binários. O Perceptron é um modelo simplificado de um neurônio biológico e também é conhecido como o protótipo de redes neurais. O algoritmo Perceptron pode aprender apenas padrões linearmente separáveis e pode ser visto como uma única unidade de uma rede neural artificial. O apresentador então explica a representação matemática do Perceptron, que inclui os pesos, a entrada e a função de ativação e os rótulos de classe do classificador binário. O vídeo explica a regra de atualização do Perceptron, que permite que o algoritmo atualize os pesos e vieses para empurrá-los para a classe de destino positiva ou negativa em caso de classificação incorreta.
  
  
• 00:05:00 Nesta seção, o palestrante descreve as etapas para implementar um modelo perceptron do zero em Python. Eles começam selecionando a taxa de aprendizado e o número de iterações para o algoritmo de otimização. Em seguida, a função de ativação é armazenada como função degrau unitário. Os pesos e vieses são inicializados como nenhum no início e o código avança para ajustar e prever as funções. Para a função de ajuste, o número de amostras e o número de recursos são obtidos dos dados de treinamento e, em seguida, os pesos e vieses são inicializados. Os rótulos de classe são ajustados para 1 ou 0. Em seguida, a otimização é realizada onde a saída linear é calculada para cada entrada. Por fim, a função de previsão é implementada onde o modelo linear e a função de ativação são usados para calcular a saída prevista para os dados de teste.
  
  
• 00:10:00 Nesta seção, o apresentador explica a implementação do perceptron do zero com Python. A regra de atualização para perceptron é delta w = alpha vezes y menos y hat vezes x e delta bias é alpha vezes y menos y hat. O apresentador usa essa regra para atualizar os pesos e o viés com base nas partes de atualização. Depois de explicar o método de ajuste, o apresentador passa para o método de previsão, onde a saída linear é calculada e então passada pela função de ativação para obter y previsto. Por fim, o apresentador testa essa implementação usando uma função auxiliar para precisão e conjuntos de dados fazem blobs com 150 amostras e dois recursos, criando um perceptron com taxa de aprendizado e número de iterações, ajustando-o com dados de treinamento e predizendo com dados de teste. A precisão acaba sendo de 100%, indicando aprendizado bem-sucedido do limite de decisão.

[MetaQuotes]

Como implementar SVM (Support Vector Machine) do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/09%20SVM

Como implementar SVM (Support Vector Machine) do zero com Python

As Support Vector Machines (SVM) visam encontrar um limite de decisão linear que maximize a separação entre classes, com o peso sendo aprendido durante o treinamento. A função de custo envolve uma perda de dobradiça determinando a que distância estamos do lado correto do limite de decisão, com um termo de regularização adicionado ao trade-off minimizando a perda e maximizando a distância. Os gradientes são calculados, as regras de atualização derivadas e os pesos inicializados, enquanto a função de previsão é a saída da função linear. O código para implementar o SVM do zero em Python usando as bibliotecas NumPy e Scikit-learn é fornecido, incluindo teste de trem de importação e divisão, conjuntos de dados e plotagem do limite de decisão e os dois hiperplanos confirmando a implementação precisa.

• 00:00:00 Nesta seção, o vídeo discute Support Vector Machines (SVM), que visa encontrar um limite de decisão linear ou hiperplano que forneça separação máxima entre as classes. O hiperplano deve ter a maior margem dos pontos ou vetores de suporte mais próximos, sendo o peso (w) o que precisa ser aprendido durante o treinamento. Uma função de perda é definida, o que envolve uma perda de dobradiça que determina o quão longe estamos do lado correto do limite de decisão. Um termo de regularização é adicionado à função de custo para compensar entre minimizar a perda e maximizar a distância para ambos os lados, com um parâmetro Lambda controlando a importância das referidas partes na função de custo.
  
  
• 00:05:00 Nesta seção, o processo de encontrar os pesos e viés para SVM é discutido. O cálculo de gradientes é explicado e as regras de atualização são derivadas do gradiente. A inicialização dos pesos também é demonstrada. Os rótulos de classe são atualizados para ter valores de -1 ou 1 e as regras de atualização são aplicadas para o número especificado de iterações. A função de previsão é simplesmente a saída da função linear que obtemos dos pesos aprendidos. Ao comparar a saída com zero, podemos decidir a classe da amostra de teste fornecida. O código para SVM é escrito em Python usando as bibliotecas NumPy e Scikit-learn.
  
  
• 00:10:00 Nesta seção, o apresentador explica como escrever um código python para implementar o SVM do zero. O método consiste em duas partes, os métodos de ajuste e previsão. O método de ajuste é o nosso treinamento, que calcula os pesos dos dados fornecidos, enquanto o método de previsão usa os pesos para prever a saída, aproximando os dados fornecidos. O apresentador explica ainda as atualizações de código de acordo com diferentes gradientes, que dependem da condição. A condição y vezes W vezes x menos B deve ser maior ou igual a um, que usamos com numpy dot para verificar. O código segue com o teste de trem de importação, divisão e conjuntos de dados de sklearn e matplotlib e cria um conjunto de dados de exemplo com dois blobs de conjuntos de dados com dois recursos e, em seguida, garante que as classes sejam -1 e mais um, divididas em conjuntos de treinamento e teste, e execute svm para prever a precisão. O apresentador também descreve o código para plotar o limite de decisão e os dois hiperplanos em mais um e menos um, o que confirma a implementação precisa.

[MetaQuotes]

Como implementar K-Means do zero com Python

Código: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/10%20KMeans

Como implementar K-Means do zero com Python

Este vídeo demonstra como implementar o algoritmo de agrupamento K-Means do zero com Python. K-Means é um algoritmo de aprendizado não supervisionado para agrupar dados não rotulados em k clusters diferentes, atualizando as médias ou centroides iterativamente até que não haja mais alterações. O vídeo aborda a inicialização de clusters vazios e a configuração de parâmetros para o número de clusters e iterações, atualização de rótulos e centroides de cluster e interrupção do loop de otimização quando não houver alteração. O palestrante também explica a importância de medir a distância euclidiana para calcular os centróides mais próximos e fornece uma função de plotagem pré-escrita do Matplotlib para visualizar o processo de agrupamento.

• 00:00:00 Nesta seção, o palestrante explica o método de aprendizado não supervisionado k-means, que envolve agrupar um conjunto de dados em k clusters diferentes e atualizar as médias ou centróides durante um processo iterativo de otimização até que não haja mais alterações. O processo de atualização dos rótulos e centros dos clusters é repetido e a fórmula dos centróides mais próximos é usada para calcular a distância euclidiana entre dois vetores de recursos. O palestrante então demonstra um exemplo de localização de três clusters em dados não rotulados e mostra como implementar k-means do zero em Python, incluindo a inicialização de clusters vazios e a configuração de parâmetros para o número de clusters e iterações. O vídeo termina com um resumo do algoritmo k-means e sua implementação em Python.
  
  
• 00:05:00 Nesta seção, o palestrante discute a implementação do K-Means do zero usando Python. Eles começam inicializando as variáveis necessárias, como listas vazias para cada cluster e centróide e, em seguida, definindo uma função de previsão em vez de um método de ajuste. Eles explicam que K-Means é uma técnica de aprendizado não supervisionado para dados não rotulados. O loop de otimização envolve atribuir amostras a centróides antes de calcular novos centróides a partir dos clusters. O palestrante observa que as funções auxiliares são necessárias para criar e obter centróides e clusters. Eles terminam mencionando que parar o loop antes do máximo de iterações é possível se não houver mais alterações.
  
  
• 00:10:00 Nesta seção, o palestrante explica a implementação de funções auxiliares para atualizar os rótulos de cluster e atribuir amostras aos centróides mais próximos. A função para atualizar os rótulos de cluster itera em cada cluster e atribui o índice de cluster ao rótulo de cada índice de amostra. O alto-falante também mostra a inicialização de listas vazias para cada cluster para atribuir os índices e, em seguida, iterar em cada amostra para atribuí-la ao centróide mais próximo. Por fim, o speak descreve as etapas para plotar os centróides e os clusters e verifica se o código precisa fornecer as etapas para plotar.
  
  
• 00:15:00 Nesta seção, o palestrante explica como implementar o algoritmo de agrupamento K-Means do zero com Python. O algoritmo usa um conjunto de dados e um número especificado de clusters como entrada e, em seguida, atribui cada ponto ao centróide mais próximo. O palestrante apresenta funções auxiliares para encontrar o centróide mais próximo e calcular a distância euclidiana entre dois pontos. Outra função auxiliar é usada para calcular a média de cada cluster, que é então atribuída ao centróide. Finalmente, o algoritmo verifica se a distância entre os centróides antigos e novos para cada cluster é zero para determinar se o algoritmo convergiu.
  
  
• 00:20:00 Nesta seção, o palestrante explica como implementar clustering K-Means do zero usando Python e numpy. Eles discutem a importância de medir a distância euclidiana e como calcular os novos centróides e rótulos de cluster. Eles também fornecem uma função de plotagem pré-escrita que usa a biblioteca matplotlib para visualizar o processo de agrupamento passo a passo. Por fim, eles demonstram a implementação em um conjunto de dados de amostra usando a função make_blobs do sklearn para criar três clusters, mostrando como o algoritmo K-Means agrupa com sucesso os pontos de dados em clusters separados. O palestrante incentiva os espectadores a verificar o código completo no Github e assistir ao restante do curso para obter explicações mais detalhadas sobre os conceitos de aprendizado de máquina.