Aprendizado de máquina em R para iniciantes com exemplo

Aprendizado de máquina com R

O aprendizado de máquina é o presente e o futuro! Do mecanismo de recomendação da Netflix ao carro autônomo do Google, tudo é aprendizado de máquina. Este blog sobre Machine Learning with R ajuda você a entender os conceitos básicos de machine learning seguido por diferentes algoritmos de machine learning e implementação desses algoritmos de machine learning com R.

Este blog sobre “Aprendizado de máquina com R” compreende estas seções:

passar por valor em java

• Compreendendo o aprendizado de máquina
• Tipos de algoritmos de aprendizado de máquina
• Implementando Algoritmos de Aprendizado de Máquina com R

Aprendizado de máquina com R | Edureka

Compreendendo o aprendizado de máquina

Como você sabe que tudo isso são peixes?

Quando criança, você pode ter se deparado com a imagem de um peixe e os professores do jardim de infância ou pais disseram que se trata de um peixe e tem algumas características específicas associadas a ele, como barbatanas, guelras, um par de olhos, cauda e assim por diante. Agora, sempre que seu cérebro encontra uma imagem com esse conjunto de características, ele a registra automaticamente como um peixe porque seu cérebro aprendeu que é um peixe.

É assim que nosso cérebro funciona, mas e uma máquina? Se a mesma imagem for enviada para uma máquina, como ela a identificará como um peixe?

É aqui que M Achine Learning entra. Continuaremos alimentando imagens de um peixe para um computador com a tag 'peixe' até que o máquina aprende todos os recursos associados com um peixe.

Uma vez que a máquina aprenda todos os recursos associados a um peixe, iremos fornecer-lhe novos dados para determinar o quanto ela aprendeu.

Em outras palavras, Dados brutos / dados de treinamento é dado à máquina, para que aprende todos os recursos associados ao Dados de treinamento. Uma vez que o aprendizado é feito, é dado Novos dados / dados de teste para determinar o quão bem a máquina aprendeu.

Vamos prosseguir neste blog de Aprendizado de Máquina com R e entender sobre os tipos de Aprendizado de Máquina.

Tipos de aprendizado de máquina

• Aprendizagem supervisionada:

O algoritmo de Aprendizagem Supervisionada aprende com um conjunto de dados conhecido (Dados de Treinamento) que possui rótulos para fazer previsões.

Regressão e Classificação são alguns exemplos de Aprendizagem Supervisionada.

#Classificação:

A classificação determina a qual conjunto de categorias pertence uma nova observação, ou seja, um algoritmo de classificação aprende todos os recursos e rótulos dos dados de treinamento e quando novos dados são fornecidos a ele, ele deve atribuir rótulos às novas observações, dependendo do que aprendeu a partir dos dados de treinamento.

Para este exemplo, se a primeira observação receber o rótulo “Homem”, então ela está corretamente classificada, mas se for dado o rótulo “Mulher”, a classificação está errada. Da mesma forma, para a segunda observação, se o rótulo dado for “Mulher”, está classificado corretamente, caso contrário, a classificação está errada.

#Regressão:

A regressão é um algoritmo de aprendizado supervisionado que ajuda a determinar como uma variável influencia outra variável.

Aqui, 'área_de_vida' é a variável independente e 'preço' é a variável dependente, ou seja, estamos determinando como o 'preço' varia em relação a 'área_de_vida'.

• Aprendizagem não supervisionada:

O algoritmo de aprendizagem não supervisionado tira inferências de dados que não possuem rótulos.

Clustering é um exemplo de aprendizagem não supervisionada. “K-means”, “Hierárquico”, “Fuzzy C-Means” são alguns exemplos de algoritmos de agrupamento.

Neste exemplo, o conjunto de observações é dividido em dois clusters. O agrupamento é feito com base na similaridade entre as observações. Há uma alta similaridade intra-cluster e baixa similaridade inter-cluster, ou seja, há uma similaridade muito alta entre todos os ônibus, mas baixa similaridade entre os ônibus e carros.

• Aprendizagem por reforço:

Aprendizado por Reforço é um tipo de algoritmo de aprendizado de máquina onde o máquina / agente em um meio Ambiente aprende o comportamento ideal para maximizar seu desempenho. O feedback de recompensa simples é necessário para que o agente aprenda seu comportamento, isso é conhecido como sinal de reforço .

Vamos levar pacman por exemplo. Enquanto o pacman continuar comendo, ele ganha pontos, mas quando se choca contra um monstro, ele perde sua vida. Assim, pacman aprende que precisa comer mais comida e evitar monstrosde modo a melhorar seu desempenho.

Implementando Aprendizado de Máquina com R:

Regressão linear:

Estaremos trabalhando com o conjunto de dados de diamantes para implementar o algoritmo de regressão linear:

Descrição do conjunto de dados:

Antes de construir qualquer modelo nos dados, devemos dividir os dados em conjuntos de “treinamento” e “teste”. O modelo será construído no conjunto de “trem” e sua precisão será verificada no conjunto de “teste”.

Precisamos carregar o pacote “caTools” para dividir os dados em dois conjuntos.

biblioteca (caTools)

O pacote “caTools” fornece uma função “sample.split ()” que ajuda a dividir os dados.

sample.split (diamonds $ price, SplitRatio = 0.65) -> split_index

65% das observações da coluna de preço foram atribuídas com o rótulo “verdadeiro” e os 35% restantes foram atribuídos com o rótulo “falso”.

subconjunto (losangos, split_index == T) -> trem subconjunto (losangos, split_index == F) -> teste

Todas as observações que têm rótulo 'verdadeiro' foram armazenadas no ' treinar ”objeto e aquelas observações com rótulo “falso” foram atribuídas ao conjunto de “teste”.

Agora que a divisão está feita e temos nossos conjuntos de 'treinamento' e 'teste', é hora de construir o modelo de regressão linear no conjunto de treinamento.

Estaremos usando a função “lm ()” para construir o modelo de regressão linear nos dados do “trem”. Estamos determinando o preço dos diamantes em relação a todas as outras variáveis ​​do conjunto de dados. O modelo construído é armazenado no objeto “mod_regress”.

lm (preço ~., dados = trem) -> mod_regress

Agora que construímos o modelo, precisamos fazer previsões no conjunto de “teste”. A função “predizer ()” é usada para obter previsões. Leva dois argumentos: o modelo construído e a Conjunto de teste. Os resultados previstos são armazenados no objeto “result_regress”.

predizer (mod_regress, test) -> result_regress

Vamos ligar os valores de preços reais do conjunto de dados de 'teste' e os valores previstos em um único conjunto de dados usando a função 'cbind ()'. O novo data-frame é armazenado em “Final_Data”

cbind (real = teste $ preço, previsto = resultado_regress) -> Final_Data 

as.data.frame (Final_Data) -> Final_Data

Uma olhada em “Final_Data” que compreende valores reais e valores previstos:

Vamos encontrar o erro subtraindo os valores previstos dos valores reais e adicionar este erro como uma nova coluna para 'Dados_Final':

(Final_Data $ Actual- Final_Data $ Predicted) -> erro

cbind (Final_Data, erro) -> Final_Data

Uma olhada em 'Dados_Final' que também inclui o erro na previsão:

Agora, iremos em frente e calcularemos “ Erro de raiz quadrada média ” o que dá um erro agregado para todas as previsões

rmse1<-sqrt(mean(Final_Data$error^2)) 

rmse1

Prosseguindo, vamos construir outro modelo, para que possamos comparar a precisão de ambos os modelos e determinar qual é o melhor.

Vamos construir um novo modelo de regressão linear no conjunto de 'trem', mas, desta vez, vamos retirar as colunas 'x' e 'y' das variáveis ​​independentes, ou seja, o 'preço' dos diamantes é determinado por todos os colunas, exceto 'x' e 'y'.

O modelo construído é armazenado em “mod_regress2”:

lm (preço ~.-y-z, dados = trem) -> mod_regress2

Os resultados previstos são armazenados em “result_regress2”

prever (mod_regress2, test) -> result_regress2

Os valores reais e previstos são combinados e armazenados em “Final_Data2”:

cbind (real = teste $ preço, previsto = resultado_regress2) -> Final_Data2 

as.data.frame (Final_Data2) -> Final_Data2

Vamos também adicionar o erro na previsão a “Final_Data2”

(Final_Data2 $ Actual- Final_Data2 $ Predicted) -> erro2

cbind (Final_Data2, error2) -> Final_Data2

Uma olhada em “Final_Data2”:

Encontrando o erro de raiz quadrada média para obter o erro de agregação:

rmse2<-sqrt(mean(Final_Data2$error^2))

Vemos que “rmse2” é marginalmente menor que “rmse1” e, portanto, o segundo modelo é ligeiramente melhor que o primeiro modelo.

Classificação:

Estaremos trabalhando com o conjunto de dados “car_purchase” para implementar particionamento recursivo que é um algoritmo de classificação.

Vamos dividir os dados em conjuntos de 'treinamento' e 'teste' usando a função 'sample.split ()' do pacote 'caTools'.

biblioteca (caTools)

65% das observações da coluna 'Adquirido' serão atribuídos rótulos 'VERDADEIROS' e o resto será atribuído rótulos 'FALSO'.

sample.split (car_purchase $ Purchased, SplitRatio = 0.65) -> split_values

Todas as observações com rótulo 'VERDADEIRO' serão armazenadas em dados de 'treinamento' e as observações com rótulo 'FALSO' serão atribuídas aos dados de 'teste'.

subconjunto (car_purchase, split_values ​​== T) -> train_data

subconjunto (car_purchase, split_values ​​== F) -> test_data

É hora de construir o algoritmo de particionamento recursivo:

Começaremos carregando o pacote ‘rpart’:

biblioteca (rpart)

A coluna 'Comprado' será a variável dependente e todas as outras colunas são as variáveis ​​independentes, ou seja, estamos determinando se a pessoa comprou o carro ou não em relação a todas as outras colunas. O modelo é construído em “train_data” e o resultado é armazenado em “mod1”.

rpart (adquirido ~., data = train_data) -> mod1

Vamos traçar o resultado:

plot (mod1, margem = 0,1) texto (mod1, bonito = T, cex = 0,8)

Agora, vamos prever os resultados em “test_data”. Estamos fornecendo o modelo rpart integrado “mod1” como o primeiro argumento, o conjunto de testes “test_data” como o segundo argumento e o tipo de predição como “classe” para o terceiro argumento. O resultado é armazenado no objeto ‘result1’.

prever (mod1, test_data, type = 'class') -> result1

Vamos avaliar a precisão do modelo usando a função 'confusãoMatrix ()' do pacote acento circunflexo.

biblioteca (circunflexo) confusãoMatrix (tabela (test_data $ Purchased, result1))

A matriz de confusão nos diz que das 90 observações em que a pessoa não comprou o carro, 79 foram corretamente classificadas como “Não” e 11 foram erroneamente classificadas como “SIM”. Da mesma forma, das 50 observações em que a pessoa realmente comprou o carro, 47 foram corretamente classificadas como “SIM” e 3 foram erroneamente classificadas como “NÃO”.

diferença entre java e classe

Podemos encontrar a precisão do modelo dividindo as previsões corretas com as previsões totais, ou seja, (79 + 47) / (79 + 47 + 11 + 3).

Clustering K-Means:

Vamos trabalhar com o conjunto de dados “iris” para implementar o agrupamento k-means:

Vamos remover a coluna 'Espécies' e criar um novo conjunto de dados que compreende apenas as primeiras quatro colunas do conjunto de dados 'íris'.

iris [1: 4] -> iris_k

Vamos considerar o número de clusters como 3. A função “Kmeans ()” pega os dados de entrada e o número de clusters nos quais os dados devem ser agrupados. A sintaxe é: kmeans (dados, k) onde k é o número de centros do cluster.

kmeans (iris_k, 3) -> k1

Analisando o agrupamento:

str (k1)

A função str () dá a estrutura dos kmeans que inclui vários parâmetros como inss, betweenss, etc, analisando qual você pode descobrir o desempenho dos kmeans.

betweenss: Entre a soma dos quadrados, ou seja, similaridade intracluster

dentro de si: dentro da soma do quadrado, ou seja, similaridade entre aglomerados

totwithinss: Soma de todas as entrelinhas de todos os clusters, ou seja, similaridade intra-cluster total

Um bom agrupamento terá um valor inferior de 'tot.withinss' e um valor mais alto de 'betweenss', que depende do número de clusters ‘k’ escolhidos inicialmente.

Chegou o momento de se tornar um especialista em Aprendizado de Máquina para aproveitar as novas oportunidades que surgirem. Isso nos leva ao fim deste “ Aprendizado de máquina com R ”Blog. Espero que este blog seja proveitoso informativo.

Edureka tem uma curadoria especial que ajuda você a ganhar experiência em algoritmos de aprendizado de máquina, como agrupamento de médias K, árvores de decisão, floresta aleatória, Bayes naive. Você aprenderá os conceitos de Estatística, Séries Temporais, Mineração de Texto e também uma introdução ao Aprendizado Profundo. Novos lotes para este curso começarão em breve !!