def rodarValidacaoCruzada(dados, classes, nProts, montecarlo, nFolds, np, intervalar = True):
if len(nProts) == 1:
nProts = ones(max(classes)+1) * nProts[0]
erros = zeros(montecarlo*nFolds)
p = shape(dados)[1]/2
if not intervalar:
p = shape(dados)[1]
consideradas = zeros(p)
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] = slvq.separarConjuntos(folds, dadosEmbaralhados, classesEmbaralhadas, fold)
[pesosFontes, fontes, classesFontes, GBEST, classesGBEST, fitnessGBEST, pesosGBEST, mins, maxs, fitness, limites] = inicializar(treinamento, classesTreinamento, nProts, np, intervalar)
[GBEST, classesGBEST, pesosGBEST] = treinar(mins, maxs, fontes, classesFontes, pesosFontes, GBEST, classesGBEST, fitnessGBEST, pesosGBEST, treinamento, classesTreinamento, np, fitness, limites, nProts, intervalar)
consideradas = consideradas + GBEST[0,:p]
erros[i*nFolds + fold] = testar(teste, classesTeste, GBEST, classesGBEST, pesosGBEST, intervalar)
print erros[i*nFolds + fold]
print erros
print mean(erros)
print std(erros)
print consideradas / (montecarlo * nFolds)
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 rodarValidacaoCruzada(dados, classes, nProts, montecarlo, nFolds, np):
global pa
global k
global n
global treinamento
global classesTreinamento
if len(nProts) == 1:
nProts = ones(max(classes) + 1) * nProts[0]
k = sum(nProts)
erros = zeros(montecarlo * nFolds)
rem = 0.0
pa = shape(dados)[1] / 2
if not intervalar:
pa = shape(dados)[1]
consideradas = zeros(pa)
nDados = size(classes)
for i in range(montecarlo):
indices = arange(nDados)
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] = slvq.separarConjuntos(folds, dadosEmbaralhados,
classesEmbaralhadas, fold)
n = shape(treinamento)[0]
inicializar(nProts, np)
VABC(np, nProts)
GBEST = PBEST[indiceGBEST]
consideradas = consideradas + around(GBEST[0, :pa]).astype(float)
#print sum(removidosPBEST[indiceGBEST])
rem = rem + float(sum(removidosPBEST[indiceGBEST]))
[erros[i * nFolds + fold],
d] = testar(teste, classesTeste, GBEST,
classesParticulas[indiceGBEST],
pesosPBEST[indiceGBEST], removidosPBEST[indiceGBEST])
print erros[i * nFolds + fold]
print erros
print mean(erros)
print std(erros)
print consideradas / (montecarlo * nFolds)
print rem / (montecarlo * nFolds)
def rodarValidacaoCruzada(dados,
classes,
nProts,
montecarlo,
nFolds,
np,
intervalar=True):
if len(nProts) == 1:
nProts = ones(max(classes) + 1) * nProts[0]
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] = slvq.separarConjuntos(folds, dadosEmbaralhados,
classesEmbaralhadas, fold)
[
particulas, velocidades, classesParticulas, PBEST,
criteriosPBEST, GBEST, classesGBEST, criterioGBEST, mins, maxs
] = inicializar(treinamento, classesTreinamento, nProts, np,
intervalar)
[GBEST, classesGBEST
] = treinar(mins, maxs, particulas, velocidades,
classesParticulas, PBEST, criteriosPBEST, GBEST,
classesGBEST, criterioGBEST, treinamento,
classesTreinamento, np, intervalar)
p = shape(teste)[1] / 2
if not intervalar:
p = shape(teste)[1]
pesos = calcularPesosPrototipos(treinamento, classesTreinamento,
GBEST[1:], classesGBEST,
GBEST[0, :p],
shape(treinamento)[0],
shape(GBEST)[0] - 1, p, intervalar)
erros[i * nFolds + fold] = testar(teste, classesTeste, GBEST,
classesGBEST, pesos, intervalar)
print erros[i * nFolds + fold]
print erros
print mean(erros)
print std(erros)
def rodarValidacaoCruzada(dados, classes, nProts, montecarlo, nFolds, np):
global pa
global k
global n
global treinamento
global classesTreinamento
if len(nProts) == 1:
nProts = ones(max(classes) + 1) * nProts[0]
k = sum(nProts)
erros = zeros(montecarlo * nFolds)
pa = shape(dados)[1] / 2
if not intervalar:
pa = shape(dados)[1]
consideradas = zeros(pa)
nDados = size(classes)
for i in range(montecarlo):
indices = arange(nDados)
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] = slvq.separarConjuntos(folds, dadosEmbaralhados,
classesEmbaralhadas, fold)
n = shape(treinamento)[0]
inicializar(nProts, np)
treinar(np, nProts)
#print GBEST
consideradas = consideradas + GBEST[0, :pa]
erros[i * nFolds + fold] = testar(teste, classesTeste, GBEST,
classesGBEST, pesosGBEST)
print erros[i * nFolds + fold]
print erros
print mean(erros)
print std(erros)
print consideradas / (montecarlo * nFolds)