Base da Implementação em Python do algoritmo em Naive Bayes, sem o ba…

project/requirements.txt

@@ -0,0 +1,3 @@
+numpy
+pandas
+matplotlib  # Para gráficos, caso deseje visualizar os resultados

project/src/experiment.py

@@ -0,0 +1,32 @@
+from naive_bayes import NaiveBayes
+from kmeans import KMeans
+from preprocess import load_data, train_test_split, normalize_data
+
+def run_experiment():
+    data = load_data('data/iris.csv')
+    X = data.iloc[:, :-1].values  # Características
+    y = data.iloc[:, -1].values  # Rótulos
+
+    X = normalize_data(X)  # Normalização dos dados
+
+    # Dividir os dados em treino e teste
+    X_train, X_test, y_train, y_test = train_test_split(X, y)
+
+    # Aplicar Naive Bayes
+    nb = NaiveBayes()
+    nb.fit(X_train, y_train)
+    y_pred = nb.predict(X_test)
+
+    # Calcular a acurácia do Naive Bayes
+    accuracy = np.mean(y_pred == y_test)
+    print(f'Acurácia do Naive Bayes: {accuracy * 100:.2f}%')
+
+    # Clusterização com KMeans
+    kmeans = KMeans(n_clusters=3)
+    kmeans.fit(X_train)
+    clusters = kmeans.labels
+
+    print("Clusters gerados pelo KMeans:", clusters)
+
+if __name__ == "__main__":
+    run_experiment()

project/src/kmeans.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+class KMeans:
+    def __init__(self, n_clusters=3):
+        self.n_clusters = n_clusters
+
+    def fit(self, X):
+        # Inicializar centróides aleatórios
+        self.centroids = X[np.random.choice(X.shape[0], self.n_clusters, replace=False)]
+        prev_centroids = np.zeros(self.centroids.shape)
+
+        while np.linalg.norm(self.centroids - prev_centroids) > 1e-4:
+            prev_centroids = self.centroids.copy()
+            # Atribuir pontos aos clusters
+            self.labels = self._assign_clusters(X)
+            # Recalcular os centróides
+            self.centroids = self._update_centroids(X)
+
+    def _assign_clusters(self, X):
+        distances = np.linalg.norm(X[:, np.newaxis] - self.centroids, axis=2)
+        return np.argmin(distances, axis=1)
+
+    def _update_centroids(self, X):
+        centroids = np.array([X[self.labels == i].mean(axis=0) for i in range(self.n_clusters)])
+        return centroids

project/src/naive_bayes.py

@@ -0,0 +1,32 @@
+import numpy as np
+
+class NaiveBayes:
+    def fit(self, X, y):
+        # Calcular a probabilidade para cada classe
+        self.classes = np.unique(y)
+        self.mean = {}
+        self.var = {}
+        self.prior = {}
+
+        for c in self.classes:
+            X_c = X[y == c]
+            self.mean[c] = X_c.mean(axis=0)
+            self.var[c] = X_c.var(axis=0)
+            self.prior[c] = len(X_c) / len(X)
+
+    def predict(self, X):
+        predictions = [self._predict(x) for x in X]
+        return np.array(predictions)
+
+    def _predict(self, x):
+        posteriors = []
+        for c in self.classes:
+            prior = np.log(self.prior[c])
+            likelihood = np.sum(np.log(self._pdf(c, x)))
+            posteriors.append(prior + likelihood)
+        return self.classes[np.argmax(posteriors)]
+
+    def _pdf(self, c, x):
+        mean = self.mean[c]
+        var = self.var[c]
+        return (1 / np.sqrt(2 * np.pi * var)) * np.exp(-(x - mean) ** 2 / (2 * var))

project/src/preprocess.py

@@ -0,0 +1,19 @@
+import pandas as pd
+import numpy as np
+
+def load_data(file_path):
+    data = pd.read_csv(file_path)
+    return data
+
+def normalize_data(X):
+    # Normalização dos dados (entre 0 e 1)
+    return (X - X.min()) / (X.max() - X.min())
+
+def train_test_split(X, y, test_size=0.3):
+    # Dividindo os dados em treino e teste
+    test_size = int(len(X) * test_size)
+    X_train = X[:len(X) - test_size]
+    X_test = X[len(X) - test_size:]
+    y_train = y[:len(y) - test_size]
+    y_test = y[len(y) - test_size:]
+    return X_train, X_test, y_train, y_test