def refinar(particula, classesParticula, pesosP): t = 1 tMax = 50 prototipos = copy(particula[1:]) variaveisConsideradas = particula[0, :pa] pesos = copy(pesosP) epsilon = 0.00001 Jatual = 1 Jdepois = -1 while t <= tMax and abs(Jatual - Jdepois) > epsilon: #fase dos prototipos distancias = calcularDistancias(prototipos, treinamento, pesos, variaveisConsideradas, n, k) graus = fcm.calcularGraus(distancias) Jatual = Jdepois Jdepois = fcm.calcularCriterio(copy(graus), distancias, classesTreinamento, classesParticula) particao = argmax(graus, 1) prototipos = fcm.calcularPrototipos(graus, treinamento, classesTreinamento, prototipos, classesParticula, particao, k) t = t + 1 #fase dos pesos pesos = calcularPesosPrototipos(prototipos, classesParticula, variaveisConsideradas, pesos) particula[1:] = prototipos return [particula, pesos]
def calcularCriterioJ(pesos, particula, classesParticula, treinamento, classesTreinamento, p, intervalar=True): alfa = 0.5 beta = 0.5 #gama = 0.3 erro = testar(treinamento, classesTreinamento, particula, classesParticula, pesos, intervalar) n = shape(treinamento)[0] k = shape(particula)[0] - 1 distancias = calcularDistancias(particula[1:], treinamento, pesos, particula[0, :p], n, k, intervalar) graus = fcm.calcularGraus(distancias) criterio = fcm.calcularCriterio(graus, distancias, classesTreinamento, classesParticula) #selecionadas = selecionarConsideradas(treinamento, particula[0,:p], intervalar) #prodCorrInterna = prod(abs(matrizDeCorrelacao(selecionadas, intervalar))) return 1.0 / (1 + alfa * erro + beta * criterio ) #+ gama * prodCorrInterna)
def refinar(treinamento, classesTreinamento, particula, classesParticula, pesosP, intervalar = True): t = 1 tMax = 50 p = shape(treinamento)[1]/2 if not intervalar: p = shape(treinamento)[1] prototipos = copy(particula[1:]) variaveisConsideradas = particula[0,:p] pesos = copy(pesosP) k = shape(prototipos)[0] n = shape(treinamento)[0] epsilon = 0.00001 Jatual = 1 Jdepois = -1 while t <= tMax and abs(Jatual - Jdepois)>epsilon: #fase dos prototipos distancias = calcularDistancias(prototipos, treinamento, pesos, variaveisConsideradas, n, k, intervalar) graus = fcm.calcularGraus(distancias) Jatual = Jdepois Jdepois = fcm.calcularCriterio(copy(graus), distancias, classesTreinamento, classesParticula) particao = argmax(graus,1) prototipos = fcm.calcularPrototipos(graus, treinamento, classesTreinamento, prototipos, classesParticula, particao, k) t = t + 1 #fase dos pesos pesos = calcularPesosPrototipos(treinamento, classesTreinamento, prototipos, classesParticula, variaveisConsideradas, n, k, p, intervalar, pesos) particula[1:] = prototipos return [particula, pesos]
def calcularCriterioJ(particula, pesos, classesParticula): erro = testar(treinamento, classesTreinamento, particula, classesParticula, pesos) / 100 distancias = calcularDistancias(particula, treinamento, pesos, n, k) graus = fcm.calcularGraus(distancias) #particao = argmin(distancias,1) #classesObtidas = classesParticula[particao] #criterio = sum(distancias.min(1) * (classesTreinamento == classesParticula[argmin(distancias,1)])) sumDistanciasProtsMembros = sum( graus.max(1)**2 * distancias.min(1) * (classesTreinamento == classesParticula[argmax(graus, 1)])) nClasses = max(classesTreinamento) + 1 medias = zeros((nClasses, shape(particula)[1])) classesTemp = arange(nClasses) #prots = particula[1:] for classe in classesTemp: #protsClasse = prots[classesParticula==classe] medias[classe] = treinamento[classesTreinamento == classe].mean( 0) #sum(protsClasse,0)/shape(protsClasse)[0] distanciasProtCentros = calcularDistancias(particula, medias, pesos, nClasses, k) #distanciasMembrosCentros = calcularDistancias(medias, treinamento, ones((nClasses,pa)), particula[0,:pa], n, nClasses) #for classe in classesTemp: # distanciasMembrosCentros[classe!=classesObtidas,classe] = 0.0 for classe in classesTemp: distanciasProtCentros[classe, classesParticula != classe] = 0.0 #criterio = sum(distanciasMembrosCentros) / sum(distanciasProtCentros) criterio = sumDistanciasProtsMembros / sum(distanciasProtCentros) return 1 / ((alfa * erro + beta * criterio) + 1)
def calcularCriterioJ2(particula, pesos, classesParticula): erro = testar(treinamento, classesTreinamento, particula, classesParticula, pesos) distancias = calcularDistancias(particula[1:], treinamento, pesos, particula[0, :pa], n, k) graus = fcm.calcularGraus(distancias) #criterio = fcm.calcularCriterio(graus, distancias, classesTreinamento, classesParticula) nClasses = max(classesTreinamento) + 1 medias = zeros((nClasses, shape(particula)[1])) classesTemp = arange(nClasses) prots = particula[1:] for classe in classesTemp: protsClasse = prots[classesParticula == classe] medias[classe] = sum(protsClasse, 0) / shape(protsClasse)[0] distanciasProtCentros = calcularDistancias(particula[1:], medias, pesos, particula[0, :pa], nClasses, k) distanciasMembrosCentros = calcularDistancias(medias, treinamento, ones((nClasses, pa)), particula[0, :pa], n, nClasses) for classe in classesTemp: distanciasMembrosCentros[classe != classesTreinamento, classe] = 0.0 for prot in range(k): distanciasProtCentros[classesTemp != classesParticula[prot], prot] = 0.0 criterio = sum(distanciasMembrosCentros) / sum(distanciasProtCentros) return 1 / ((alfa * erro + beta * criterio) + 1)
def calcularCriterioJ(particula, pesos, classesParticula): #selecionadas = selecionarConsideradas(treinamento, particula[0,:pa], intervalar) #maxCorr = (abs(matrizDeCorrelacao(selecionadas, intervalar)) - eye (sum(around(particula[0,:pa])))).max() erro = testar(treinamento, classesTreinamento, particula, classesParticula, pesos) / 100 distancias = calcularDistancias(particula[1:], treinamento, pesos, particula[0, :pa], n, k) graus = fcm.calcularGraus(distancias) #particao = argmin(distancias,1) #classesObtidas = classesParticula[particao] #criterio = sum(distancias.min(1) * (classesTreinamento == classesParticula[argmin(distancias,1)])) sumDistanciasProtsMembros = sum( graus.max(1)**2 * distancias.min(1) * (classesTreinamento == classesParticula[argmax(graus, 1)])) #nClasses = max(classesTreinamento)+1 #medias = zeros((nClasses, shape(particula)[1])) #classesTemp = arange(nClasses) #prots = particula[1:] #for classe in classesTemp: #protsClasse = prots[classesParticula==classe] # medias[classe] = treinamento[classesTreinamento == classe].mean(0)#sum(protsClasse,0)/shape(protsClasse)[0] #distanciasProtCentros = calcularDistancias(particula[1:], medias, pesos, particula[0,:pa], nClasses, k) #distanciasMembrosCentros = calcularDistancias(medias, treinamento, ones((nClasses,pa)), particula[0,:pa], n, nClasses) #for classe in classesTemp: # distanciasMembrosCentros[classe!=classesObtidas,classe] = 0.0 #for classe in classesTemp: # distanciasProtCentros[classe,classesParticula != classe] = 0.0 #criterio = sum(distanciasMembrosCentros) / sum(distanciasProtCentros) criterio = sumDistanciasProtsMembros #/ sum(distanciasProtCentros) return 1 / ((alfa * erro + beta * criterio) + 1)
def testar(teste, classesTeste, particula, classesParticula, pesos): n = shape(teste)[0] distancias = calcularDistancias(particula, teste, pesos, n, k) graus = fcm.calcularGraus(distancias) particao = argmax(graus, 1) classesResultantes = array([classesParticula[prot] for prot in particao]) numeroErros = float(size(classesTeste[classesTeste != classesResultantes])) return (numeroErros / n) * 100.0
def calcularPesosPrototipos(treinamento, classesTreinamento, prototipos, classesPrototipos, variaveisConsideradas, n, k, p, intervalar = True, pesos = []): nClasses = max(classesTreinamento + 1) consideradas = around(variaveisConsideradas) if len(pesos) == 0: pesos = ones((k,p)) distancias = calcularDistancias(prototipos, treinamento, pesos, variaveisConsideradas, n, k, intervalar) graus = fcm.calcularGraus(distancias) particao = argmax(graus,1) distancias = (graus**2)*distancias deltas = zeros((k,p)) for prot in range(k): membros = fcm.getMembros(treinamento, classesTreinamento, particao, classesPrototipos, prot) if size(membros) > 0: if intervalar: mins = (prototipos[prot,::2] - membros[:,::2])**2 maxs = (prototipos[prot,1::2] - membros[:,1::2])**2 diff = mins + maxs else: diff = (prototipos[prot] - membros)**2 grausMembros = (graus[ fcm.getMembros(treinamento, classesTreinamento, particao, classesPrototipos, prot, True), prot] ** 2) deltas[prot,:] = sum(grausMembros.reshape((size(grausMembros),1)) * consideradas * diff,0) errados = [i for i in where(particao==prot)[0] if classesTreinamento[i] != classesPrototipos[prot]] distancias[errados,:] = 0 distancias[where(particao!=prot)[0],prot] = 0 somatoriosClasses = array([]) for classe in range(nClasses): somatoriosClasses = append(somatoriosClasses, sum(distancias[:,where(classesPrototipos == classe)[0]])) if any(somatoriosClasses == 0): pesosClasses = ones(nClasses) else: pesosClasses = (prod(somatoriosClasses)**(1.0/nClasses))/somatoriosClasses pesosPrototipos = ones(k) for classe in range(nClasses): somatorioPrototipos = sum(distancias[:,where(classesPrototipos == classe)[0]],axis=0) protsClasse = where(classesPrototipos == classe)[0] if any(somatorioPrototipos == 0): pesosPrototipos[protsClasse] = ones(size(protsClasse)) * pesosClasses[classe]**(1.0/size(protsClasse)) else: pesosPrototipos[protsClasse] = ((pesosClasses[classe]* prod(somatorioPrototipos))**(1.0/size(protsClasse)))/somatorioPrototipos for prot in protsClasse: achou = False index = 0 delta = deltas[prot,:] while achou == False and index < p: if consideradas[index] == 1.0 and delta[index] == 0.0: achou = True index = index + 1 if achou == False: produtorio = (pesosPrototipos[prot]*prod(delta[delta > 0]))**(1.0/sum(consideradas)) pesos[prot,:] = array([produtorio / v if v > 0 else 0 for v in delta]) else: pesos[prot,:] = array([pesosPrototipos[prot]**(1.0/sum(consideradas)) if v > 0 else 0 for v in consideradas]) return pesos
def testar(teste, classesTeste, particula, classesParticula, pesos, intervalar = True): k = shape(particula)[0] - 1 n = shape(teste)[0] p = shape(teste)[1]/2 if not intervalar: p = shape(teste)[1] distancias = calcularDistancias(particula[1:], teste, pesos, particula[0,:p], n, k, intervalar) graus = fcm.calcularGraus(distancias) particao = argmax(graus,1) classesResultantes = array([classesParticula[prot] for prot in particao]) numeroErros = float(size(classesTeste[classesTeste != classesResultantes])) return (numeroErros / n)*100.0