Gaussian Naive Bayes, explicado: um guia visual com…

Grupo Shoslh
outubro 11, 2024
9:25 pm
Sem comentários

ALGORITMO DE CLASSIFICAÇÃO

Suposições em forma de sino para melhores previsões

⛳️ More CLASSIFICATION ALGORITHM, explained: · Dummy Classifier · K Nearest Neighbor Classifier · Bernoulli Naive Bayes ▶ Gaussian Naive Bayes · Decision Tree Classifier · Logistic Regression · Support Vector Classifier · Multilayer Perceptron (soon!)

Com base em nosso cláusula anterior sobre Bernoulli Naive Bayes, que lida com dados binários, agora exploramos Gaussian Naive Bayes para dados contínuos. Ao contrário da abordagem binária, levante algoritmo assume que cada particularidade segue uma distribuição normal (Gaussiana).

Cá, veremos uma vez que o Gaussian Naive Bayes lida com dados contínuos em forma de sino – gerando previsões precisas – todos sem entrar na matemática complexa do Teorema de Bayes.

Todos os recursos visuais: criados pelo responsável usando Canva Pro. Otimizado para celular; pode parecer superdimensionado na espaço de trabalho.

Porquê outras variantes do Naive Bayes, o Gaussian Naive Bayes faz a suposição “ingênua” de independência de recursos. Ele assume que os recursos são condicionalmente independentes, oferecido o rótulo da classe.

No entanto, enquanto Bernoulli Naive Bayes é adequado para conjuntos de dados com características binárias, Gaussian Naive Bayes assume que as características seguem uma normal contínua (Gaussiana) distribuição. Embora esta suposição nem sempre seja verdadeira na verdade, ela simplifica os cálculos e muitas vezes leva a resultados surpreendentemente precisos.

Bernoulli NB assume dados binários, Multinomial NB trabalha com contagens discretas e Gaussian NB lida com dados contínuos assumindo uma distribuição normal.

Ao longo deste cláusula, usaremos levante conjunto de dados de golfe sintético (feito pelo responsável) uma vez que exemplo. Oriente conjunto de dados prevê se uma pessoa jogará golfe com base nas condições climáticas.

Colunas: ‘RainfallAmount’ (em mm), ‘Temperatura’ (em Celsius), ‘Umidade’ (em %), ‘WindSpeed’ (em km/h) e ‘Play’ (Sim/Não, recurso intuito)

# IMPORTING DATASET #
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as npdataset_dict = {
'Rainfall': [0.0, 2.0, 7.0, 18.0, 3.0, 3.0, 0.0, 1.0, 0.0, 25.0, 0.0, 18.0, 9.0, 5.0, 0.0, 1.0, 7.0, 0.0, 0.0, 7.0, 5.0, 3.0, 0.0, 2.0, 0.0, 8.0, 4.0, 4.0],
'Temperature': [29.4, 26.7, 28.3, 21.1, 20.0, 18.3, 17.8, 22.2, 20.6, 23.9, 23.9, 22.2, 27.2, 21.7, 27.2, 23.3, 24.4, 25.6, 27.8, 19.4, 29.4, 22.8, 31.1, 25.0, 26.1, 26.7, 18.9, 28.9],
'Humidity': [85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0, 90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0, 65.0, 70.0, 60.0, 95.0, 70.0, 78.0],
'WindSpeed': [2.1, 21.2, 1.5, 3.3, 2.0, 17.4, 14.9, 6.9, 2.7, 1.6, 30.3, 10.9, 3.0, 7.5, 10.3, 3.0, 3.9, 21.9, 2.6, 17.3, 9.6, 1.9, 16.0, 4.6, 3.2, 8.3, 3.2, 2.2],
'Play': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No', 'No', 'Yes', 'Yes', 'No', 'No', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No', 'Yes']
}
df = pd.DataFrame(dataset_dict)
# Set feature matrix X and target vector y
X, y = df.drop(columns='Play'), df['Play']
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.5, shuffle=False)
print(pd.concat([X_train, y_train], axis=1), end='nn')
print(pd.concat([X_test, y_test], axis=1))

Gaussian Naive Bayes trabalha com dados contínuos, assumindo que cada particularidade segue uma distribuição Gaussiana (normal).

Calcule a verosimilhança de cada classe nos dados de treinamento.
Sua visita nos ajuda a continuar oferecendo o melhor para você! gu od b hx qs of og ia qt oi oj ok qu om on oo qv oq or os qw ou ov ow qp qq qr bk">Para cada recurso e classe, estime a média e a variância dos valores dos recursos dentro dessa classe.
Para uma novidade instância:
um. Para cada classe, calcule a função de densidade de verosimilhança (PDF) de cada valor de recurso sob a distribuição gaussiana desse recurso dentro da classe.
b. Multiplique a verosimilhança da classe pelo resultado dos valores PDF para todos os recursos.
Preveja a classe com a maior verosimilhança resultante.

Gaussian Naive Bayes usa a distribuição normal para modelar a verosimilhança de diferentes valores de recursos para cada classe. Em seguida, combina essas probabilidades para fazer uma previsão.

Transformando dados distribuídos não gaussianos

Lembra que levante algoritmo assume ingenuamente que todos os recursos de ingressão têm distribuição gaussiana/normal?

Porquê não temos certeza sobre a distribuição de nossos dados, principalmente para recursos que claramente não seguem uma distribuição gaussiana, utilizar uma transformação de potência (uma vez que Box-Cox) antes de usar Gaussian Naive Bayes pode ser proveitoso. Essa abordagem pode ajudar a tornar os dados mais parecidos com Gauss, o que se alinha melhor com as suposições do algoritmo.

Todas as colunas são dimensionadas usando Power Transformation (Box-Cox Transformation) e depois padronizadas.

from sklearn.preprocessing import PowerTransformer# Initialize and fit the PowerTransformer
pt = PowerTransformer(standardize=True) # Standard Scaling already included
X_train_transformed = pt.fit_transform(X_train)
X_test_transformed = pt.transform(X_test)

Agora estamos prontos para o treinamento.

1. Operação de verosimilhança de classe: Para cada classe, calcule sua verosimilhança: (Número de instâncias nesta classe) / (Número totalidade de instâncias)

from fractions import Fractiondef calc_target_prob(attr):
total_counts = attr.value_counts().sum()
prob_series = attr.value_counts().apply(lambda x: Fraction(x, total_counts).limit_denominator())
return prob_series
print(calc_target_prob(y_train))

2. Operação de verosimilhança de recurso : para cada recurso e cada classe, calcule a média (μ) e o meandro padrão (σ) dos valores dos recursos dentro dessa classe usando os dados de treinamento. Em seguida, calcule a verosimilhança usando a fórmula da Função de Densidade de Verosimilhança Gaussiana (PDF).

Para cada exigência climática, determine a média e o meandro padrão para as instâncias “SIM” e “NÃO”. Em seguida, calcule seu PDF usando a fórmula PDF para distribuição normal/Gaussiana.

O mesmo processo é aplicado a todos os outros recursos.

def calculate_class_probabilities(X_train_transformed, y_train, feature_names):
classes = y_train.unique()
equations = pd.DataFrame(índice=classes, columns=feature_names)for cls in classes:
X_class = X_train_transformed[y_train == cls]
mean = X_class.mean(axis=0)
std = X_class.std(axis=0)
k1 = 1 / (std * np.sqrt(2 * np.pi))
k2 = 2 * (std ** 2)
for i, column in enumerate(feature_names):
equation = f"{k1[i]:.3f}·exp(-(x-({mean[i]:.2f}))²/{k2[i]:.3f})"
equations.loc[cls, column] = equation
return equations
# Use the function with the transformed training data
equation_table = calculate_class_probabilities(X_train_transformed, y_train, X.columns)
# Display the equation table
print(equation_table)

3. Suavização: Gaussian Naive Bayes usa uma abordagem de suavização exclusiva. Ao contrário da suavização de Laplace em outras variantes, ela adiciona um valor minúsculo (0,000000001 vezes a maior variação) a todas as variações. Isso evita a instabilidade numérica causada pela partilha por zero ou por números muito pequenos.

Dada uma novidade instância com recursos contínuos:

1. Coleta de Verosimilhança:
Para cada classe verosímil:
· Comece com a verosimilhança desta classe ocorrer (verosimilhança de classe).
· Para cada recurso na novidade instância, calcule a função de densidade de verosimilhança Sua visita nos ajuda a continuar oferecendo o melhor para você! recurso dentro da classe.

Para o ID 14, calculamos o PDF de cada recurso para as instâncias “SIM” e “NÃO”.

2. Operação e previsão de pontuação:
Para cada lição:
· Multiplique todos os valores PDF coletados.
· O resultado é a pontuação desta lição.
· A turma com maior pontuação é a previsão.

from scipy.stats import normdef calculate_class_probability_products(X_train_transformed, y_train, X_new, feature_names, target_name):
classes = y_train.unique()
n_features = X_train_transformed.shape[1]
# Create column names using novo feature names
column_names = [target_name] + list(feature_names) + ['Product']
probability_products = pd.DataFrame(índice=classes, columns=column_names)
for cls in classes:
X_class = X_train_transformed[y_train == cls]
mean = X_class.mean(axis=0)
std = X_class.std(axis=0)
prior_prob = np.mean(y_train == cls)
probability_products.loc[cls, target_name] = prior_prob
feature_probs = []
for i, feature in enumerate(feature_names):
prob = norm.pdf(X_new[0, i], mean[i], std[i])
probability_products.loc[cls, feature] = prob
feature_probs.append(prob)
product = prior_prob * np.prod(feature_probs)
probability_products.loc[cls, 'Product'] = product
return probability_products
# Assuming X_new is your new sample reshaped to (1, n_features)
X_new = np.array([-1.28, 1.115, 0.84, 0.68]).reshape(1, -1)
# Calculate probability products
prob_products = calculate_class_probability_products(X_train_transformed, y_train, X_new, X.columns, y.name)
# Display the probability product table
print(prob_products)

Para levante conjunto de dados específico, esta precisão é considerada bastante boa.

from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score# Initialize and train the Gaussian Naive Bayes model
gnb = GaussianNB()
gnb.fit(X_train_transformed, y_train)
# Make predictions on the test set
y_pred = gnb.predict(X_test_transformed)
# Calculate the accuracy
accuracy = accuracy_score(y_test, y_pred)
# Print the accuracy
print(f"Accuracy: {accuracy:.4f}")

GaussianNB é sabido por sua simplicidade e eficiência. A principal coisa a lembrar sobre seus parâmetros é:

anteriores: Oriente é o parâmetro mais notável, semelhante a Bernoulli Naive Bayes. Na maioria dos casos, não é necessário configurá-lo manualmente. Por padrão, é calculado a partir dos seus dados de treinamento, o que geralmente funciona muito.
var_suavização: Oriente é um parâmetro de firmeza que raramente precisa ser ajustado. (o padrão é 0,000000001)

A principal peroração é que esse algoritmo foi projetado para funcionar muito imediatamente. Na maioria das situações, você pode usá-lo sem se preocupar com o ajuste dos parâmetros.

Prós:

Simplicidade: mantém a particularidade de fácil implementação e compreensão.
Eficiência: permanece rápido no treinamento e na previsão, tornando-o adequado para aplicações em larga graduação com recursos contínuos.
Flexibilidade com dados: lida muito com conjuntos de dados pequenos e grandes, adaptando-se à graduação do problema em questão.
Manipulação contínua de recursos: prospera com recursos contínuos e com valor real, tornando-o ideal para tarefas uma vez que prever resultados com valor real ou trabalhar com dados onde os recursos variam continuamente.

Contras:

Suposição de Independência: ainda assume que os recursos são condicionalmente independentes de congraçamento com a classe, o que pode não ser válido em todos os cenários do mundo real.
Suposição de distribuição gaussiana: funciona melhor quando os valores dos recursos realmente seguem uma distribuição normal. Distribuições não normais podem levar a um desempenho inferior do ideal (mas podem ser corrigidas com o Power Transformation que discutimos)
Sensibilidade a valores discrepantes: podem ser significativamente afetados por valores discrepantes nos dados de treinamento, pois distorcem os cálculos de média e variância.

Gaussian Naive Bayes se destaca uma vez que um classificador eficiente para uma ampla gama de aplicações envolvendo dados contínuos. Sua capacidade de mourejar com recursos de valor real estende seu uso além das tarefas de classificação binária, tornando-o uma escolha ideal para inúmeras aplicações.

Embora faça algumas suposições sobre os dados (independência de recursos e distribuição normal), quando essas condições são atendidas, ele oferece um desempenho robusto, tornando-o um predilecto entre cientistas de dados iniciantes e experientes por seu estabilidade entre simplicidade e poder.

import pandas as pd
from sklearn.naive_bayes import GaussianNB
from sklearn.preprocessing import PowerTransformer
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split# Load the dataset
dataset_dict = {
'Rainfall': [0.0, 2.0, 7.0, 18.0, 3.0, 3.0, 0.0, 1.0, 0.0, 25.0, 0.0, 18.0, 9.0, 5.0, 0.0, 1.0, 7.0, 0.0, 0.0, 7.0, 5.0, 3.0, 0.0, 2.0, 0.0, 8.0, 4.0, 4.0],
'Temperature': [29.4, 26.7, 28.3, 21.1, 20.0, 18.3, 17.8, 22.2, 20.6, 23.9, 23.9, 22.2, 27.2, 21.7, 27.2, 23.3, 24.4, 25.6, 27.8, 19.4, 29.4, 22.8, 31.1, 25.0, 26.1, 26.7, 18.9, 28.9],
'Humidity': [85.0, 90.0, 78.0, 96.0, 80.0, 70.0, 65.0, 95.0, 70.0, 80.0, 70.0, 90.0, 75.0, 80.0, 88.0, 92.0, 85.0, 75.0, 92.0, 90.0, 85.0, 88.0, 65.0, 70.0, 60.0, 95.0, 70.0, 78.0],
'WindSpeed': [2.1, 21.2, 1.5, 3.3, 2.0, 17.4, 14.9, 6.9, 2.7, 1.6, 30.3, 10.9, 3.0, 7.5, 10.3, 3.0, 3.9, 21.9, 2.6, 17.3, 9.6, 1.9, 16.0, 4.6, 3.2, 8.3, 3.2, 2.2],
'Play': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No', 'No', 'Yes', 'Yes', 'No', 'No', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No', 'Yes']
}
df = pd.DataFrame(dataset_dict)
# Prepare data for model
X, y = df.drop('Play', axis=1), (df['Play'] == 'Yes').astype(int)
# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, shuffle=False)
# Apply PowerTransformer
pt = PowerTransformer(standardize=True)
X_train_transformed = pt.fit_transform(X_train)
X_test_transformed = pt.transform(X_test)
# Train the model
nb_clf = GaussianNB()
nb_clf.fit(X_train_transformed, y_train)
# Make predictions
y_pred = nb_clf.predict(X_test_transformed)
# Check accuracy
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.4f}")