def inicializar(treinamento, classesTreinamento, nProts, nAbelhas, intervalar = True):
np = int(nAbelhas/2.0)
if intervalar:
p = shape(treinamento)[1]/2
mins = treinamento[:,::2].min(0)
maxs = treinamento[:,1::2].max(0)
else:
mins = treinamento.min(0)
maxs = treinamento.max(0)
p = shape(treinamento)[1]
fontes = zeros((np,sum(nProts)+1,shape(treinamento)[1]))
pesosFontes = ones((np,sum(nProts),p))
classesFontes = zeros((np,sum(nProts)))
fitness = zeros(np)
limites = zeros(np)
for fonte in range(np):
variaveisConsideradas = random.rand(shape(treinamento)[1])
[prototipos, classesPrototipos] = slvq.iniciarPrototiposPorSelecao(treinamento, classesTreinamento, nProts)
variaveisConsideradas[p:] = 0
fontes[fonte] = append([variaveisConsideradas],prototipos,axis=0)
classesFontes[fonte] = classesPrototipos
fontes[fonte] = ajustarMinsMaxs(ajustarVariaveisConsideradas(fontes[fonte],p), mins, maxs, intervalar)
pesosFontes[fonte] = calcularPesosPrototipos(treinamento, classesTreinamento, fontes[fonte,1:], classesFontes[fonte], fontes[fonte,0,:p], shape(treinamento)[0], shape(fontes[fonte])[0]-1, p, intervalar)
fitness[fonte] = calcularCriterioJ(pesosFontes[fonte], fontes[fonte], classesFontes[fonte], treinamento, classesTreinamento, p, intervalar)
indice = argmax(fitness)
GBEST = copy(fontes[indice])
classesGBEST = copy(classesFontes[indice])
fitnessGBEST = fitness[indice]
pesosGBEST = copy(pesosFontes[indice])
return [pesosFontes, fontes, classesFontes, GBEST, classesGBEST, fitnessGBEST, pesosGBEST, mins, maxs, fitness, limites]
def gerarSolucao(nProts):
#nClasses = classesTreinamento.max()+ 1
variaveisConsideradas = random.rand(shape(treinamento)[1])
[prototipos,
classes] = slvq.iniciarPrototiposPorSelecao(treinamento,
classesTreinamento, nProts)
#prototipos = zeros((sum(nProts),shape(treinamento)[1]))
#classes = zeros(sum(nProts))
#inicio = 0
#fim = 0
#variaveisConsideradas[pa:] = 0
#for classe in range(nClasses):
# inicio = fim
# fim = fim + nProts[classe]
# membros = where(classesTreinamento == classe)[0]
# for var in range(pa):
# if intervalar:
# minimo = min(treinamento[membros,2*var])
# maximo = max(treinamento[membros,2*var+1])
# prototipos[inicio:fim,2*var] = minimo + random.rand(nProts[classe])*(maximo - minimo)
# prototipos[inicio:fim,2*var+1] = minimo + random.rand(nProts[classe])*(maximo - minimo)
# else:
# prototipos[inicio:fim,var] = minimo + random.rand(nProts[classe])*(maximo - minimo)
# classes[inicio:fim] = classe
fonte = ajustarMinsMaxs(
ajustarVariaveisConsideradas(
append([variaveisConsideradas], prototipos, axis=0)))
pesos = calcularPesosPrototipos(fonte[1:], classes, fonte[0, :pa])
return [fonte, classes, pesos]
def gerarSolucao(nProts):
[prototipos,
classes] = slvq.iniciarPrototiposPorSelecao(treinamento,
classesTreinamento, nProts)
pesos = calcularPesosPrototipos(prototipos, classes)
return [prototipos, classes, pesos]
def rodarValidacaoCruzada(dados, classes, nMedias, montecarlo, nFolds):
erros = zeros(montecarlo * nFolds)
n = size(classes)
for i in range(montecarlo):
indices = arange(n)
random.shuffle(indices)
dadosEmbaralhados = dados[indices, :]
classesEmbaralhadas = classes[indices]
folds = slvq.separarFolds(dadosEmbaralhados, classesEmbaralhadas,
nFolds)
for fold in range(nFolds):
print i * nFolds + fold
[
treinamento, classesTreinamento, teste, classesTeste,
validacao, classesValidacao
] = separarConjuntos(folds, dadosEmbaralhados, classesEmbaralhadas,
fold)
[prototipos, classesPrototipos
] = slvq.iniciarPrototiposPorSelecao(treinamento,
classesTreinamento, nMedias)
[prototipos,
pesos] = blvq.treinar(treinamento, classesTreinamento, prototipos,
classesPrototipos, 500)
[prototipos, pesos] = treinar(treinamento, classesTreinamento,
prototipos, classesPrototipos,
validacao, classesValidacao, pesos)
erros[i * nFolds + fold] = slvq.testar(teste, classesTeste,
prototipos,
classesPrototipos, pesos)
print erros
print mean(erros)
print std(erros)
def gerarSolucao(nProts):
variaveisConsideradas = random.rand(shape(treinamento)[1])
[prototipos,
classes] = slvq.iniciarPrototiposPorSelecao(treinamento,
classesTreinamento, nProts)
fonte = ajustarMinsMaxs(
ajustarVariaveisConsideradas(
append([variaveisConsideradas], prototipos, axis=0)))
pesos = calcularPesosPrototipos(fonte[1:], classes, fonte[0, :pa])
return [fonte, classes, pesos]
def inicializar(treinamento, classesTreinamento, nProts, np, intervalar=True):
if intervalar:
p = shape(treinamento)[1] / 2
mins = treinamento[:, ::2].min(0)
maxs = treinamento[:, 1::2].max(0)
else:
mins = treinamento.min(0)
maxs = treinamento.max(0)
p = shape(treinamento)[1]
particulas = zeros((np, sum(nProts) + 1, shape(treinamento)[1]))
velocidades = random.rand(np, sum(nProts) + 1, shape(treinamento)[1])
classesParticulas = zeros((np, sum(nProts)))
criterios = zeros(np)
for particula in range(np):
variaveisConsideradas = random.rand(shape(treinamento)[1])
[prototipos, classesPrototipos
] = slvq.iniciarPrototiposPorSelecao(treinamento, classesTreinamento,
nProts)
variaveisConsideradas[p:] = 0
particulas[particula] = append([variaveisConsideradas],
prototipos,
axis=0)
classesParticulas[particula] = classesPrototipos
particulas[particula] = ajustarMinsMaxs(
ajustarVariaveisConsideradas(particulas[particula], p), mins, maxs,
intervalar)
pesos = calcularPesosPrototipos(treinamento, classesTreinamento,
particulas[particula, 1:],
classesParticulas[particula],
particulas[particula, 0, :p],
shape(treinamento)[0],
shape(particulas[particula])[0] - 1, p,
intervalar)
criterios[particula] = calcularCriterioJ(pesos, particulas[particula],
classesParticulas[particula],
treinamento,
classesTreinamento, p,
intervalar)
PBEST = copy(particulas)
criteriosPBEST = copy(criterios)
indice = argmin(criterios)
GBEST = copy(particulas[indice])
classesGBEST = copy(classesParticulas[indice])
criterioGBEST = criterios[indice]
return [
particulas, velocidades, classesParticulas, PBEST, criteriosPBEST,
GBEST, classesGBEST, criterioGBEST, mins, maxs
]
def enviarAbelhasEscoteiras(nFontes, fontes, classesFontes, pesosFontes, mins, maxs, fitness, limites, treinamento, classesTreinamento, limite, nProts, intervalar = True):
ind = argmax(limites)
if limites[ind] >= limite:
p = shape(treinamento)[1]/2
if not intervalar:
p = shape(treinamento)[1]
[va, pesos] = refinar(treinamento, classesTreinamento, copy(fontes[ind]), classesFontes[ind], copy(pesosFontes[ind]), intervalar)
f = calcularCriterioJ(pesos, va, classesFontes[ind], treinamento, classesTreinamento, p, intervalar)
if f > fitness[ind]:
fitness[ind] = f
limites[ind] = 0
fontes[ind] = va
pesosFontes[ind] = pesos
else:
variaveisConsideradas = random.rand(shape(treinamento)[1])
[prototipos, classesPrototipos] = slvq.iniciarPrototiposPorSelecao(treinamento, classesTreinamento, nProts)
variaveisConsideradas[p:] = 0
fontes[ind] = append([variaveisConsideradas],prototipos,axis=0)
classesFontes[ind] = classesPrototipos
fontes[ind] = ajustarMinsMaxs(ajustarVariaveisConsideradas(fontes[ind],p), mins, maxs, intervalar)
pesosFontes[ind] = calcularPesosPrototipos(treinamento, classesTreinamento, fontes[ind,1:], classesFontes[ind], fontes[ind,0,:p], shape(treinamento)[0], shape(fontes[ind])[0]-1, p, intervalar)
fitness[ind] = calcularCriterioJ(pesosFontes[ind], fontes[ind], classesFontes[ind], treinamento, classesTreinamento, p, intervalar)
limites[ind] = 0.0
return [fontes, pesosFontes, fitness, limites]