Projeto ML p02 tentativa

import pandas as pd
from sklearn.model_selection import KFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from Lista02 import FuncoesML as fun
from scipy import stats
import numpy as np
from random import randint
from sklearn.cluster import KMeans
from Lista03 import pso as pso

KCLUSTERS = 4

def WCSS(distance):
    retorno = []
    for x in distance:
        soma = 0
        for z in x:
            soma += z ** 2
        retorno.append(soma)

    return retorno


def break_vectors(vector):
    global KCLUSTERS
    retorno = np.split(vector, KCLUSTERS)
    return retorno


def wcssGenetic(centers):
    global KCLUSTERS
    array = break_vectors(centers)

    kmeans = KMeans(KCLUSTERS, init=pd.DataFrame(array), max_iter=1, n_init=1)
    kmeans.fit(pd.DataFrame(df_final))

    return kmeans.inertia_


def generatepopulation(X, numberpopu, K, rng):
    population = []

    for x in range(numberpopu):
        first = rng.permutation(X.shape[0])[:K]
        population.append(np.concatenate(X[first]))

    return population

#Criando a classe receita que irá conter nome, classe e vetor de ingredientes
class Receita:
    Name = None
    Class = 0
    ingredientes = []
    ingredientesnorm = []


#Método que retorna o vetor de ingredientes
    def getingrednorm(self):
        return self.ingredientesnorm

#Construtor da classe receita
    def __init__(self, name, Class, ingredientes):
        self.Name = name
        self.Class = Class
        self.ingredientes = ingredientes

#Método que adiciona ingredientes no vetor de ingredientes
    def adicionaringrediente(self, ingrediente):
        self.ingredientes.append(ingrediente)

#abrindo o arquivo com a base de dados
reshipe = open("C:/Users/Auricelia/Desktop/DatasetsML/ReshibaseQ.txt", "rt", encoding="utf8")

#criando o vetor de receitas
receitas = []

# preenchendo o vetor de receitas
for receita in reshipe:
    dividido = receita.split(sep=',')
    dividido[(len(dividido) - 1)] = dividido[(len(dividido) - 1)].replace('\n', '')
    ingredientes = []

    for x in range(2, len(dividido)):
        ingredientes.append(dividido[x])

    receitas.append(Receita(dividido[1], dividido[0], ingredientes))

#vetor que irá receber todos os ingredientes sem repetição para fazer os vetores binários
todosingredientes = []

#preenchendo o vetor 'todosingredientes' sem repetição
for rec in receitas:
    for ingrediente in rec.ingredientes:

        if todosingredientes.__contains__(ingrediente) == False:
            todosingredientes.append(ingrediente)
#ordenando o vetor
todosingredientes = sorted(todosingredientes)

# preenchendo nos objetos receita o vetor binário com 0

for rec in receitas:
    norm = []
    for y in range(0, len(todosingredientes)):
        norm.append(0)
    rec.ingredientesnorm = norm

# Colocando 1 na posição em que existe o ingrediente

for rec in receitas:
    for y in rec.ingredientes:
        pos = todosingredientes.index(y)
        rec.ingredientesnorm[pos] = 1

# Vetor que irá receber os vetores binários de ingreientes de cada receita
arrayingredientesnorm = []

# Preenchendo o vetor com os ingredientes normalizados

for rec in receitas:
    arrayingredientesnorm.append(rec.ingredientesnorm)

# Vetor que irá receber as classes de cada receita
arrayclasse = []

# preenchendo o vetor com as classes de cada receita
for rec in receitas:
    arrayclasse.append(rec.Class)

# criando o dataframe que irá armazenar os ingredientes
df = pd.DataFrame(arrayingredientesnorm)

#adicionando a classe ao dataframe
df['Class'] = arrayclasse
lista = df['Class']
del df['Class']
df_final = np.array(df)
print('TAMANHO DF :',df_final[0].size*4)

print("VAI COMEÇAR")
resultsKmeans = []              # ARRAY QUE SALVA AS ACURACIAS DO KMEANS
resultKmeansHybrid = []         # ARRAY QUE SALVA AS ACURACIAS DO HYBRID
acuraciaKmeans = []             # ARRAY QUE SALVA O WCSS DO K MEANS
acuraciaHybrid = []             # ARRAY QUE SALVA O WCSS DO HYBRID
for y in range(10):

    print("RODADA " + str(y))
    resultparcial = []
    distance = []
    h = randint(1, 10)
    rng = np.random.RandomState(h)

    print("-----------------------------------------------")
    for algumacoisa in range(20):                                 # AQUI RODA O KMEANS 20 VEZES
        print("VEZ KMEANS " + str(algumacoisa))
        centers, labels, distance = fun.find_clusters(df_final, KCLUSTERS, rng, 100)        # AQUI VOCE PASSA 4 PARAMETROS, O SEU DATAFRAME EM UM NUMPYARRAY, O NUMERO DE CLASSES, O RNG QUE É A SEED E O NUMERO MAX DE ITERAÇÕES
        print(fun.accuracy_majority_vote(df_final,labels,lista,2))  # PRINTA O VOTO MAJORITARIO, QUE RECEBE SEU DATAFRAME EM FORMA DE ARRAY, OS LABELS DO RETORNO DE CIMA, E A LISTA QUE É A COLUNA DE LABELS DO SEU DATAFRAME ANTES DE VIRAR NUMPYARRAY
        acuraciaKmeans.append(fun.accuracy_majority_vote(df_final,labels,lista,2))
        retorno = WCSS(distance)
        resultparcial.append(retorno[len(retorno) - 1])


    resultparcial = np.sort(resultparcial)

    resultsKmeans.append(resultparcial[0])

    population = generatepopulation(df_final, 20, KCLUSTERS, rng)

    p = pso(20, wcssGenetic, 0, 200000, 1608, 100, init=population)
    array = np.array(p.get_Gbest())
    array = np.split(array, 4)

    print("Hybrid:")
    cen, lbl, dis = fun.find_clustersgenetic(df_final, KCLUSTERS, 100, array)
    print(fun.accuracy_majority_vote(df_final, lbl, lista, 4))
    acuraciaHybrid.append(fun.accuracy_majority_vote(df_final, lbl, lista, 4))

    ret = WCSS(dis)
    resultKmeansHybrid.append(ret[len(ret) - 1])

    # num = retorno[len(retorno) - 1]
    # dictionary[h] = num

#
# print("Distancias" ,distance)

resultKmeansHybrid = np.sort(resultKmeansHybrid)
resultsKmeans = np.sort(resultsKmeans)
print("Media Hibrido", np.mean(resultKmeansHybrid))
print("Media sem hibrido", np.mean(resultsKmeans))
print(resultKmeansHybrid)
print("Nao hibrido", resultsKmeans)

print("MEDIAS")
print(np.mean(acuraciaKmeans), "ACURACIA KMEANS")
print(np.mean(acuraciaHybrid), "ACURACIA KHYBRID")