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