TechCodeview

• O algoritmo Naïve Bayes é um algoritmo de aprendizagem supervisionada, baseado em Teorema de Bayes e usado para resolver problemas de classificação.
• É usado principalmente em classificação de texto que inclui um conjunto de dados de treinamento de alta dimensão.
• Classificador Naïve Bayes é um dos algoritmos de classificação simples e eficazes que ajuda na construção de modelos rápidos de aprendizado de máquina que podem fazer previsões rápidas.
É um classificador probabilístico, o que significa que prevê com base na probabilidade de um objeto.
• Alguns exemplos populares de algoritmo Naïve Bayes são filtragem de spam, análise sentimental e classificação de artigos .

Por que é chamado de Naïve Bayes?

O algoritmo Naïve Bayes é composto por duas palavras Naïve e Bayes, que podem ser descritas como:

javascript ao clicar

Ingênuo: É denominado Naïve porque assume que a ocorrência de um determinado recurso é independente da ocorrência de outros recursos. Por exemplo, se a fruta for identificada com base na cor, forma e sabor, então a fruta vermelha, esférica e doce é reconhecida como uma maçã. Daí que cada característica individualmente contribui para identificar que se trata de uma maçã sem depender uma da outra.Bayes: É chamado de Bayes porque depende do princípio do Teorema de Bayes.

Teorema de Bayes:

• O teorema de Bayes também é conhecido como Regra de Bayes ou Lei de Bayes , que é usado para determinar a probabilidade de uma hipótese com conhecimento prévio. Depende da probabilidade condicional.
• A fórmula do teorema de Bayes é dada como:

Onde,

P(A|B) é probabilidade posterior : Probabilidade da hipótese A sobre o evento observado B.

P(B|A) é probabilidade de verossimilhança : Probabilidade da evidência dada que a probabilidade de uma hipótese é verdadeira.

P(A) é probabilidade anterior : Probabilidade de hipótese antes de observar as evidências.

P(B) é probabilidade marginal : Probabilidade de Evidência.

Funcionamento do Classificador Naïve Bayes:

O funcionamento do Classificador Naïve Bayes pode ser entendido com a ajuda do exemplo abaixo:

Suponha que temos um conjunto de dados de condições do tempo e variável de destino correspondente ' Jogar '. Portanto, usando este conjunto de dados, precisamos decidir se devemos jogar ou não em um determinado dia, de acordo com as condições climáticas. Portanto, para resolver este problema, precisamos seguir os passos abaixo:

1. Converta o conjunto de dados fornecido em tabelas de frequência.
2. Gere uma tabela de probabilidade encontrando as probabilidades de determinados recursos.
3. Agora, use o teorema de Bayes para calcular a probabilidade posterior.

Problema : Se o tempo estiver ensolarado, o Jogador deve jogar ou não?

Solução : Para resolver isso, primeiro considere o conjunto de dados abaixo:

Tabela de frequência das Condições Meteorológicas:

Tabela de probabilidades condições climáticas:

Aplicando o teorema de Bayes:

P(Sim|Ensolarado)= P(Ensolarado|Sim)*P(Sim)/P(Ensolarado)

P(Ensolarado|Sim)= 3/10= 0,3

P (ensolarado) = 0,35

P(Sim)=0,71

tutorial java para iniciantes

Então P(Sim|Ensolarado) = 0,3*0,71/0,35= 0,60

P(Não|Ensolarado)= P(Ensolarado|Não)*P(Não)/P(Ensolarado)

P (Ensolarado | NÃO) = 2/4 = 0,5

P(Não)= 0,29

P (ensolarado) = 0,35

Então P(Não|Ensolarado)= 0,5*0,29/0,35 = 0,41

Então, como podemos ver no cálculo acima que P(Sim|Ensolarado)>P(Não|Ensolarado)

Portanto, em um dia ensolarado, o jogador pode jogar.

Vantagens do classificador Naïve Bayes:

• Naïve Bayes é um dos algoritmos de ML rápidos e fáceis para prever uma classe de conjuntos de dados.
• Ele pode ser usado para classificações binárias e multiclasses.
• Ele tem um bom desempenho em previsões multiclasse em comparação com outros algoritmos.
• É a escolha mais popular para problemas de classificação de texto .

Desvantagens do classificador Naïve Bayes:

• Naive Bayes assume que todos os recursos são independentes ou não relacionados, portanto, não pode aprender a relação entre os recursos.

Aplicações do Classificador Naïve Bayes:

• É usado para Pontuação de crédito .
• É usado em classificação de dados médicos .
• Pode ser usado em previsões em tempo real porque o Naïve Bayes Classifier é um aluno ávido.
• É usado na classificação de texto, como Filtragem de spam e Análise de sentimentos .

Tipos de modelo Naïve Bayes:

Existem três tipos de modelo Naive Bayes, que são fornecidos a seguir:

Gaussiano: O modelo gaussiano assume que os recursos seguem uma distribuição normal. Isso significa que se os preditores assumirem valores contínuos em vez de discretos, o modelo assumirá que esses valores são amostrados da distribuição gaussiana.Multinomial: O classificador Multinomial Naïve Bayes é usado quando os dados são distribuídos multinomialmente. É usado principalmente para problemas de classificação de documentos, significa que um determinado documento pertence a uma categoria, como Esportes, Política, Educação, etc.
O classificador usa a frequência de palavras para os preditores.Bernoulli: O classificador Bernoulli funciona de forma semelhante ao classificador Multinomial, mas as variáveis ​​preditoras são variáveis ​​booleanas independentes. Por exemplo, se uma determinada palavra estiver presente ou não em um documento. Este modelo também é famoso por tarefas de classificação de documentos.

Implementação Python do algoritmo Naïve Bayes:

Agora implementaremos um algoritmo Naive Bayes usando Python. Então, para isso, usaremos o ' dados do usuário ' conjunto de dados , que usamos em nosso outro modelo de classificação. Portanto podemos facilmente comparar o modelo Naive Bayes com os outros modelos.

Passos para implementar:

• Etapa de pré-processamento de dados
• Ajustando Naive Bayes ao conjunto de treinamento
• Prevendo o resultado do teste
• Teste a precisão do resultado (matriz de criação de confusão)
• Visualizando o resultado do conjunto de testes.

1) Etapa de pré-processamento de dados:

Nesta etapa, iremos pré-processar/preparar os dados para que possamos utilizá-los de forma eficiente em nosso código. É semelhante ao que fizemos no pré-processamento de dados. O código para isso é fornecido abaixo:

 Importing the libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd # Importing the dataset dataset = pd.read_csv('user_data.csv') x = dataset.iloc[:, [2, 3]].values y = dataset.iloc[:, 4].values # Splitting the dataset into the Training set and Test set from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.25, random_state = 0) # Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() x_train = sc.fit_transform(x_train) x_test = sc.transform(x_test) 

No código acima, carregamos o conjunto de dados em nosso programa usando ' conjunto de dados = pd.read_csv('user_data.csv') . O conjunto de dados carregado é dividido em conjunto de treinamento e teste e, em seguida, dimensionamos a variável de recurso.

A saída para o conjunto de dados é fornecida como:

2) Ajustando Naive Bayes ao conjunto de treinamento:

Após a etapa de pré-processamento, agora ajustaremos o modelo Naive Bayes ao conjunto de treinamento. Abaixo está o código para isso:

string para int java

 # Fitting Naive Bayes to the Training set from sklearn.naive_bayes import GaussianNB classifier = GaussianNB() classifier.fit(x_train, y_train) 

No código acima, usamos o Classificador GaussianoNB para ajustá-lo ao conjunto de dados de treinamento. Também podemos usar outros classificadores conforme nossa necessidade.

Saída:

 Out[6]: GaussianNB(priors=None, var_smoothing=1e-09) 

3) Previsão do resultado do conjunto de testes:

Agora vamos prever o resultado do conjunto de testes. Para isso, criaremos uma nova variável preditora y_pred e usará a função de previsão para fazer as previsões.

 # Predicting the Test set results y_pred = classifier.predict(x_test) 

Saída:

A saída acima mostra o resultado do vetor de predição y_pred e vetor real y_test. Podemos ver que algumas predicações são diferentes dos valores reais, que são as previsões incorretas.

4) Criando Matriz de Confusão:

Agora verificaremos a precisão do classificador Naive Bayes usando a matriz Confusion. Abaixo está o código para isso:

 # Making the Confusion Matrix from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) 

Saída:

Como podemos ver na saída da matriz de confusão acima, existem 7+3= 10 previsões incorretas e 65+25=90 previsões corretas.

5) Visualizando o resultado do conjunto de treinamento:

A seguir visualizaremos o resultado do conjunto de treinamento usando o Classificador Na�ve Bayes. Abaixo está o código para isso:

 # Visualising the Training set results from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train X1, X2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step = 0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(X1, X2, classifier.predict(nm.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha = 0.75, cmap = ListedColormap(('purple', 'green'))) mtp.xlim(X1.min(), X1.max()) mtp.ylim(X2.min(), X2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Naive Bayes (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Saída:

Na saída acima, podemos ver que o classificador Na�ve Bayes segregou os pontos de dados com o limite fino. É a curva gaussiana como usamos GaussianoNB classificador em nosso código.

exemplo java olá mundo

6) Visualizando o resultado do conjunto de testes:

 # Visualising the Test set results from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test X1, X2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step = 0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(X1, X2, classifier.predict(nm.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape), alpha = 0.75, cmap = ListedColormap(('purple', 'green'))) mtp.xlim(X1.min(), X1.max()) mtp.ylim(X2.min(), X2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Naive Bayes (test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Saída:

A saída acima é a saída final para dados do conjunto de teste. Como podemos ver o classificador criou uma curva gaussiana para dividir as variáveis ​​‘comprado’ e ‘não adquirido’. Existem algumas previsões erradas que calculamos na matriz de confusão. Mas ainda assim é um classificador muito bom.