本文整理汇总了Python中Assurance.dice方法的典型用法代码示例。如果您正苦于以下问题：Python Assurance.dice方法的具体用法？Python Assurance.dice怎么用？Python Assurance.dice使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Assurance的用法示例。
在下文中一共展示了Assurance.dice方法的13个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(dominios, targets, anotacoes, atributos):
mediaDice = []
mediaMasi = []
acuracia = 0.
numeroDescricoes = 0.
print 50 * "*"
print 50 * "-"
print "Experimento GRE3D7 Randomico"
print 50 * "-"
for anotacao in anotacoes:
contexto = anotacao["caracteristicas"]["context"]
target = targets[contexto]
A = ass.parse(anotacao["descricao"])
atributos.remove("type")
random.shuffle(atributos)
atributos.insert(0, "type")
descricao = IncrementalAlgorithmRelational2(dominios[contexto], target, atributos, False).run()
B = ass.parse(descricao, target)
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1
numeroDescricoes = numeroDescricoes + 1
mediaDice.append(DICE)
mediaMasi.append(MASI)
anotacao["dice"] = DICE
anotacao["masi"] = MASI
anotacao["algoritmo"] = descricao
# print anotacao["descricao"]
# print anotacao["algoritmo"]
# print anotacao["caracteristicas"]
# print anotacao["dice"]
# print anotacao["masi"]
# print 50 * "*"
print "DICE: ", num.mean(mediaDice)
print "MASI: ",num.mean(mediaMasi)
print "ACURACIA: ",acuracia / numeroDescricoes
print 50 * "*"
print "\n"
return anotacoes
示例2: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(dominios, targets, anotacoes, atributos):
frequencia = countAttributeFrequency(anotacoes)
preferencia = getListaPreferencia(frequencia, atributos)
frequencia = countAttributeFrequency(anotacoes)
mediaDice = {}
mediaMasi = {}
acuracia = 0.
numeroDescricoes = 0.
for anotacao in anotacoes:
contexto = anotacao["caracteristicas"]["context"]
participante = str(anotacao["caracteristicas"]["trial"])
A = ass.parse(anotacao["descricao"])
#random.shuffle(atributos)
descricao = IncrementalAlgorithmRelational3(dominios[contexto], targets[contexto], preferencia[participante], False).run()
B = ass.parse(descricao, targets[contexto])
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1
numeroDescricoes = numeroDescricoes + 1
if participante not in mediaDice.keys():
mediaDice[participante] = []
mediaMasi[participante] = []
mediaDice[participante].append(DICE)
mediaMasi[participante].append(MASI)
anotacao["dice"] = DICE
anotacao["masi"] = MASI
anotacao["algoritmo"] = descricao
# print anotacao["descricao"]
# print anotacao["algoritmo"]
# print anotacao["caracteristicas"]
# print anotacao["dice"]
# print anotacao["masi"]
# print 100 * "*"
print num.mean(mediaDice.values())
print num.mean(mediaMasi.values())
print acuracia / numeroDescricoes
print "\n"示例3: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(dominios, targets, anotacoes, atributos, probabilidade):
frequencia = countAttributeFrequency(anotacoes)
lista_preferencia = getListaPreferencia(frequencia, atributos)
frequencia = countAttributeFrequency(anotacoes)
mediaDice = []
mediaMasi = []
acuracia = 0.
numeroDescricoes = 0.
for anotacao in anotacoes:
contexto = anotacao["caracteristicas"]["context"]
participante = str(anotacao["caracteristicas"]["trial"])
A = ass.parse(anotacao["descricao"])
#random.shuffle(atributos)
descricao = IncrementalAlgorithmRelational5(dominios[contexto], targets[contexto], lista_preferencia, frequencia, probabilidade, 4480, False).run()
B = ass.parse(descricao, targets[contexto])
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1
numeroDescricoes = numeroDescricoes + 1
mediaDice.append(DICE)
mediaMasi.append(MASI)
anotacao["dice"] = DICE
anotacao["masi"] = MASI
anotacao["algoritmo"] = descricao
# print anotacao["descricao"]
# print anotacao["algoritmo"]
# print anotacao["caracteristicas"]
# print anotacao["dice"]
# print anotacao["masi"]
# print 100 * "*"
print "Dice: ", num.mean(mediaDice)
print "Masi: ",num.mean(mediaMasi)
print "Acuracia: ",acuracia / numeroDescricoes
print "\n"示例4: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(contextos, folds, atributos):
print 100 * "-"
print "Experimento GIVE"
print "algoritmo IA com a lista de preferencia ordenada pela frequencia de atributos"
print 100 * "-"
mediaDice = []
mediaMasi = []
acuracia = 0.
numeroDescricoes = 0.
mediaFoldDice = {}
mediaFoldMasi = {}
acuraciaFold = {}
numeroDescricoesFold = {}
for i in range(1, len(folds)+1):
fold = str(i)
mediaFoldDice[fold] = []
mediaFoldMasi[fold] = []
acuraciaFold[fold] = 0.0
numeroDescricoesFold[fold] = 0.0
[treinamento, teste] = toList(folds, fold)
frequencia = countAttributeFrequency(treinamento)
preferencia = defineListaPreferencia(frequencia, atributos)
for anotacao in teste:
contexto = anotacao["caracteristicas"]["context"]
participante = str(anotacao["caracteristicas"]["trial"])
target = anotacao["caracteristicas"]["target"]
A = ass.parse(anotacao["descricao"])
#random.shuffle(atributos)
descricao = IncrementalAlgorithmRelational3(contextos[contexto], target, preferencia, False).run()
B = ass.parse(descricao)
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1
acuraciaFold[fold] = acuraciaFold[fold] + 1
numeroDescricoes = numeroDescricoes + 1
numeroDescricoesFold[fold] = numeroDescricoesFold[fold] + 1
mediaFoldDice[fold].append(DICE)
mediaFoldMasi[fold].append(MASI)
mediaDice.append(DICE)
mediaMasi.append(MASI)
anotacao["dice"] = DICE
anotacao["masi"] = MASI
anotacao["algoritmo"] = descricao
# print anotacao["descricao"]
# print anotacao["algoritmo"]
# print anotacao["caracteristicas"]
# print anotacao["dice"]
# print anotacao["masi"]
# print 100 * "*"
print "Fold: " + fold
print "DICE: " + str(num.mean(mediaFoldDice[fold]))
print "MASI: " + str(num.mean(mediaFoldMasi[fold]))
print "Acuracia: " + str(acuraciaFold[fold] / numeroDescricoesFold[fold])
print 20 * "*"
print 10 * "-"
print "Geral: "
print "DICE: " + str(num.mean(mediaDice))
print "MASI: " + str(num.mean(mediaMasi))
print "Acuracia: " + str(acuracia / numeroDescricoes)
print 10 * "-"
print "\n"示例5: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(dominios, targets, anotacoes, atributos):
frequencia = countAttributeFrequency(anotacoes)
lista_preferencia = {}
lista_preferencia["target"] = []
while len(frequencia["target"]) != 0:
maximo = max(frequencia["target"].values())
for key in frequencia["target"].keys():
if frequencia["target"][key] == maximo:
lista_preferencia["target"].append(key)
del(frequencia["target"][key])
lista_preferencia["landmark"] = []
while len(frequencia["landmark"]) != 0:
maximo = max(frequencia["landmark"].values())
for key in frequencia["landmark"].keys():
if frequencia["landmark"][key] == maximo:
lista_preferencia["landmark"].append(key)
del(frequencia["landmark"][key])
mediaDice = []
mediaMasi = []
acuracia = 0.
numeroDescricoes = 0.
for anotacao in anotacoes:
contexto = anotacao["caracteristicas"]["context"]
participante = str(anotacao["caracteristicas"]["trial"])
A = ass.parse(anotacao["descricao"])
#random.shuffle(atributos)
descricao = IncrementalAlgorithmRelational3(dominios[contexto], targets[contexto], lista_preferencia, False).run()
B = ass.parse(descricao, targets[contexto])
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1
numeroDescricoes = numeroDescricoes + 1
mediaDice.append(DICE)
mediaMasi.append(MASI)
anotacao["dice"] = DICE
anotacao["masi"] = MASI
anotacao["algoritmo"] = descricao
# print anotacao["descricao"]
# print anotacao["algoritmo"]
# print anotacao["caracteristicas"]
# print anotacao["dice"]
# print anotacao["masi"]
# print 100 * "*"
print num.mean(mediaDice)
print num.mean(mediaMasi)
print acuracia / numeroDescricoes
print "\n"
print lista_preferencia示例6: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(dominios, targets, folds, atributos, participantes, incluirParticipante):
featureVector = parser.parseFeatureVector(dominios, targets)
inputs = {}
for fold in folds:
frequencias = countAttributeFrequencyIndividual(folds, fold)
inputs[fold] = parser.parseSVMInput(folds[fold], featureVector, participantes, frequencias, incluirParticipante)
resultadoTotal = []
dice = []
masi = []
acuracia = 0.0
# print 10 * "*"
# if incluirParticipante == True:
# print "SVM com o id do participante"
# else:
# print "SVM sem o id do participante"
# print 10 * "*"
for fold in ["1","2","3","4","5","6"]:
print "FOLD: " + fold
resultados = svm.run(inputs, fold)
resultadoTotal.append(resultados)
acertos = resultados[0]
total = resultados[1]
expressoes = resultados[2]
tp = resultados[3]
tn = resultados[4]
fp = resultados[5]
fn = resultados[6]
for expressao in expressoes:
contexto = expressao["anotacao"]["caracteristicas"]["context"]
descricao = defineExpressao(expressao["previsoes"], dominios[contexto], targets[contexto])
descricaoR = expressao["anotacao"]["descricao"]
A = ass.parse(descricao)
B = ass.parse(descricaoR)
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1.0
dice.append(DICE)
masi.append(MASI)
# if expressao["previsoes"]["relation"] > 0:
# print "Descricao Prevista : " + str(expressao["previsoes"])
# print "Descricao Prevista : " + str(descricao)
# print "Descricao Real : " + str(expressao["classes"])
# print "Descricao Real : " + str(descricaoR)
# print "Dice: " + str(DICE)
# print 30 * "-"
for atributo in acertos.keys():
print "Atributo: " + str(atributo)
print "Acuracia: " + str(acertos[atributo] / total[atributo])
# print "Verdadeiros Positivos: " + str(tp[atributo])
# print "Falsos Positivos: " + str(fp[atributo])
# print "Verdadeiros Negativos: " + str(tn[atributo])
# print "Falsos Negativos: " + str(fn[atributo])
print 10 * "-"
print 50 * "*"
print 50 * "*"
print "Expressoes: "
print "Dice Total: " + str(np.mean(dice))
print "Masi Total: " + str(np.mean(masi))
print "Acuracia: " + str(acuracia / len(dice))
print 50 * "*"
acertosT = {}
totalT = {}
for resultados in resultadoTotal:
acertos = resultados[0]
total = resultados[1]
for atributo in acertos.keys():
if atributo not in acertosT:
acertosT[atributo] = 0.0
totalT[atributo] = 0.0
acertosT[atributo] = acertosT[atributo] + acertos[atributo]
totalT[atributo] = totalT[atributo] + total[atributo]
for atributo in acertosT.keys():
print "Atributo: " + str(atributo)
print "Acuracia: " + str(acertosT[atributo] / totalT[atributo])
print 10 * "-"
return resultadoTotal, dice, masi, acuracia示例7: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(dominios, targets, folds, atributos, participantesInput, incluirParticipante):
featureVector = parser.parseFeatureVector(dominios, targets)
inputs = {}
frequencias = {}
participantes = {}
# Inicializa Vetor de Caracteristicas
for fold in folds:
frequencias[fold] = utils.countAttributeFrequencyIndividual(folds, fold)
participantes[fold] = parser.descriptionsMeans(folds, fold, dominios)
inputs[fold] = parser.parseSVMInput(folds[fold], featureVector, participantes[fold], frequencias[fold], incluirParticipante)
resultadoTotal = []
diceTotal = []
masiTotal = []
acuraciaTotal = 0.0
for testeFold in folds:
teste = folds[testeFold]
inputTeste = inputs[testeFold]
treinamentoFolds = {}
inputsTreinamento = {}
for foldAux in folds:
if foldAux != testeFold:
treinamentoFolds[foldAux] = folds[foldAux]
inputsTreinamento[foldAux] = inputs[foldAux]
combinacoes = run_validation(dominios, treinamentoFolds, featureVector, participantesInput, incluirParticipante)
resultados = svm.run2(inputsTreinamento, inputTeste, combinacoes)
resultadoTotal.append(resultados)
acertos = resultados[0]
total = resultados[1]
expressoes = resultados[2]
tp = resultados[3]
tn = resultados[4]
fp = resultados[5]
fn = resultados[6]
dice = []
masi = []
acuracia = 0
for expressao in expressoes:
contexto = expressao["anotacao"]["caracteristicas"]["context"]
descricao = utils.defineExpressao(expressao["previsoes"], dominios[contexto], targets[contexto])
descricaoR = expressao["anotacao"]["descricao"]
A = ass.parse(descricao)
B = ass.parse(descricaoR)
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
# print 20 * "-"
# print descricaoR
# print descricao
# print DICE
# print 20 * "-"
if DICE == 1.0:
acuracia = acuracia + 1.0
acuraciaTotal = acuraciaTotal + 1.0
dice.append(DICE)
masi.append(MASI)
diceTotal.append(DICE)
masiTotal.append(MASI)
# for atributo in acertos.keys():
# print "Attribute: " + str(atributo)
# print "Accuracy: " + str(acertos[atributo] / total[atributo])
# print 10 * "-"
#
# print 50 * "*"
#
# print "\n"
# print "General:"
# print 50 * "*"
# print "Expressions: "
# print "Dice: " + str(np.mean(dice))
# print "Masi: " + str(np.mean(masi))
# print "Accuracy: " + str(acuracia / len(dice))
# print "\n"
# print "\n"
# print "General:"
# print 50 * "*"
# print "Expressions: "
# print "Dice: " + str(np.mean(diceTotal))
# print "Masi: " + str(np.mean(masiTotal))
# print "Accuracy: " + str(acuraciaTotal / len(diceTotal))
# print "\n"
acertosT = {}
totalT = {}
#.........这里部分代码省略.........
示例8: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(dominios, targets, folds, atributos, participantes, incluirParticipante):
featureVector = parser.parseFeatureVector(dominios, targets)
inputs = {}
# Cross Validation
#folds = cross.crossValidation(6, annotations)
# Inicializa Vetor de Caracteristicas
for fold in folds:
frequencias = countAttributeFrequencyIndividual(folds, fold)
inputs[fold] = parser.parseSVMInputSecondVersion(folds[fold], featureVector, participantes, frequencias, incluirParticipante)
resultadoTotal = []
diceTotal = []
masiTotal = []
acuraciaTotal = 0.0
for testeFold in folds:
teste = folds[testeFold]
inputTeste = inputs[testeFold]
treinamentoFolds = {}
inputsTreinamento = {}
for foldAux in folds:
if foldAux != testeFold:
treinamentoFolds[foldAux] = folds[foldAux]
inputsTreinamento[foldAux] = inputs[foldAux]
acertos = {}
total = {}
tp = {}
tn = {}
fp = {}
fn = {}
keys = folds.keys()
keys.sort()
for fold in treinamentoFolds:
# print "Fold: ", fold
# print 50 * "-"
resultados = svm.run(inputsTreinamento, fold)
for combination in resultados.keys():
if combination not in acertos.keys():
acertos[combination] = {}
total[combination] = {}
tp[combination] = {}
tn[combination] = {}
fp[combination] = {}
fn[combination] = {}
for svm1 in resultados[combination][0].keys():
if svm1 not in acertos[combination].keys():
acertos[combination][svm1] = 0.0
total[combination][svm1] = 0.0
tp[combination][svm1] = 0.0
tn[combination][svm1] = 0.0
fp[combination][svm1] = 0.0
fn[combination][svm1] = 0.0
acertos[combination][svm1] = acertos[combination][svm1] + resultados[combination][0][svm1]
total[combination][svm1] = total[combination][svm1] + resultados[combination][1][svm1]
tp[combination][svm1] = tp[combination][svm1] + resultados[combination][3][svm1]
tn[combination][svm1] = tn[combination][svm1] + resultados[combination][4][svm1]
fp[combination][svm1] = fp[combination][svm1] + resultados[combination][5][svm1]
fn[combination][svm1] = fn[combination][svm1] + resultados[combination][6][svm1]
combinacoes = {}
acuracias = {}
for combination in acertos.keys():
aux = combination.split(",")
C = float(aux[0])
gamma = float(aux[1])
# print 20 * "-"
# print str(C) + " - " + str(gamma)
# print 20 * "-"
for svm1 in acertos[combination].keys():
acuracia = acertos[combination][svm1] / total[combination][svm1]
# print str(svm1) + ": " + str(acuracia)
if svm1 not in combinacoes.keys():
acuracias[svm1] = acuracia
combinacoes[svm1] = {}
combinacoes[svm1]["C"] = C
combinacoes[svm1]["gamma"] = gamma
elif acuracia > acuracias[svm1]:
acuracias[svm1] = acuracia
combinacoes[svm1]["C"] = C
combinacoes[svm1]["gamma"] = gamma
# print "\n"
# print "Combinacao: " + str(combinacoes)
resultados = svm.run2(inputsTreinamento, inputTeste, combinacoes)
resultadoTotal.append(resultados)
acertos = resultados[0]
#.........这里部分代码省略.........
示例9: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(trials, folds, atributos, participantes, incluirParticipante):
featureVector = parser.parseFeatureVector(trials)
frequencias = {}
inputs = {}
for fold in folds:
frequencias[fold] = countAttributeFrequency(folds, fold)
participantes[fold] = parser.descriptionsMeans(folds, fold)
inputs[fold] = parser.parseSVMInput(folds[fold], featureVector, participantes[fold], frequencias[fold], incluirParticipante)
resultadoTotal = []
dice = []
masi = []
acuracia = 0.0
# print 10 * "*"
# if incluirParticipante == True:
# print "SVM com o id do participante"
# else:
# print "SVM sem o id do participante"
# print 10 * "*"
for fold in ["1","2","3","4","5","6", "7","8","9","10"]:
# print "FOLD: " + fold
resultados = tree.run(inputs, fold)
resultadoTotal.append(resultados)
acertos = resultados[0]
total = resultados[1]
expressoes = resultados[2]
tp = resultados[3]
tn = resultados[4]
fp = resultados[5]
fn = resultados[6]
for expressao in expressoes:
descricao = defineExpressao(expressao)
descricaoR = expressao[expressao.keys()[0]]["anotacao"]["descricao"]
A = ass.parse(descricao)
B = ass.parse(descricaoR)
if len(A) == 0 and len(B) == 0:
DICE = 0.0
MASI = 0.0
else:
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1.0
dice.append(DICE)
masi.append(MASI)
# print "Descricao Prevista : " + str(descricao)
# print "Descricao Real : " + str(descricaoR)
# print "Dice: " + str(DICE)
# print 30 * "-"
# for atributo in acertos.keys():
# print "Atributo: " + str(atributo)
# print "Acuracia: " + str(acertos[atributo] / total[atributo])
# # print "Verdadeiros Positivos: " + str(tp[atributo])
# # print "Falsos Positivos: " + str(fp[atributo])
# # print "Verdadeiros Negativos: " + str(tn[atributo])
# # print "Falsos Negativos: " + str(fn[atributo])
# print 10 * "-"
#
# print 50 * "*"
# print 50 * "*"
# print "Expressoes: "
# print "Dice Total: " + str(np.mean(dice))
# print "Masi Total: " + str(np.mean(masi))
# print "Acuracia: " + str(acuracia / len(dice))
# print 50 * "*"
acertosT = {}
totalT = {}
for resultados in resultadoTotal:
acertos = resultados[0]
total = resultados[1]
for atributo in acertos.keys():
if atributo not in acertosT:
acertosT[atributo] = 0.0
totalT[atributo] = 0.0
acertosT[atributo] = acertosT[atributo] + acertos[atributo]
totalT[atributo] = totalT[atributo] + total[atributo]
# for atributo in acertosT.keys():
# print "Atributo: " + str(atributo)
# print "Acuracia: " + str(acertosT[atributo] / totalT[atributo])
# print 10 * "-"
return resultadoTotal, dice, masi, acuracia示例10: getConcorcanciaCompleta
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def getConcorcanciaCompleta():
resultados = parseExpressoes()
propriedades = resultados[0]
descricoes = resultados[1]
#anotadores
anotadores = descricoes.keys()
#participantes
participantes = descricoes["adriano"].keys()
#mapas
mapas = descricoes["adriano"]["1"].keys()
acertos = 0
acertosParticipante = {}
acertosMapa= {}
expressoes = 0
expressoesParticipante = {}
expressoesMapa = {}
classList = []
classes = {}
classes[anotadores[0]] = {}
classes[anotadores[1]] = {}
for participante in participantes:
if participante not in acertosParticipante.keys():
acertosParticipante[participante] = 0.
expressoesParticipante[participante] = 0.
for mapa in mapas:
if mapa not in acertosMapa.keys():
acertosMapa[mapa] = 0.
expressoesMapa[mapa] = 0.
if mapa in descricoes[anotadores[0]][participante].keys():
A = simpleParse(descricoes[anotadores[0]][participante][mapa])
if mapa in descricoes[anotadores[1]][participante].keys():
B = simpleParse(descricoes[anotadores[1]][participante][mapa])
if str(A) not in classList:
classList.append(str(A))
if str(B) not in classList:
classList.append(str(B))
if str(A) not in classes[anotadores[0]].keys():
classes[anotadores[0]][str(A)] = 1
else:
classes[anotadores[0]][str(A)] = classes[anotadores[0]][str(A)] + 1
if str(B) not in classes[anotadores[1]].keys():
classes[anotadores[1]][str(B)] = 1
else:
classes[anotadores[1]][str(B)] = classes[anotadores[1]][str(B)] + 1
dice = ass.dice(A, B)
if dice >= 1.0:
# print 10 * "-"
# print "Participante: " + participante
# print "Mapa: " + mapa
# print "Expressao A: " + str(A)
# print "Expressao B: " + str(B)
# print 10 * "-"
acertos = acertos + 1.
acertosParticipante[participante] = acertosParticipante[participante] + 1.
acertosMapa[mapa] = acertosMapa[mapa] + 1.
expressoes = expressoes + 1.
expressoesParticipante[participante] = expressoesParticipante[participante] + 1.
expressoesMapa[mapa] = expressoesMapa[mapa] + 1.
# print acertos
# print expressoes
print "Concordancia Completa: "
concordancia = acertos / expressoes
print "Precisao Total: " + str(concordancia)
probE = 0.
for classe in classList:
if classe in classes[anotadores[0]].keys():
part1 = classes[anotadores[0]][classe] / 1980.
else:
part1 = 0.
if classe in classes[anotadores[1]].keys():
part2= classes[anotadores[1]][classe] / 1980.
else:
part2 = 0.
part3 = part1 * part2
probE = probE + part3
print "Precisao Aleatoria: " + str(probE)
print "KAPPA: " + str((concordancia - probE) / (1 - probE))
# for participante in participantes:
# print 10 * "-"
# print "Precisao participante " + participante + ": " + str(acertosParticipante[participante] / expressoesParticipante[participante])
#.........这里部分代码省略.........
示例11: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(dominios, targets, folds, atributos, probabilidade):
mediaDice = []
mediaMasi = []
acuracia = 0.
numeroDescricoes = 0.
mediaDiceSuperespecificada = []
mediaMasiSuperespecificada = []
acuraciaSuperespecificada = 0.
numeroDescricoesSuperespecificada = 0.
for i in range(1, len(folds)+1):
fold = str(i)
print "Fold: ", fold
print 50 * "-"
[treinamento, teste] = toList(folds, fold)
frequencia = countAttributeFrequency(treinamento)
preferencia = getListaPreferencia(frequencia, atributos)
frequencia = countAttributeFrequency(treinamento)
mediaFoldDice = []
mediaFoldMasi = []
acuraciaFold = 0.
numeroDescricoesFold = 0.
mediaFoldDiceSuperespecificada = []
mediaFoldMasiSuperespecificada = []
acuraciaFoldSuperespecificada = 0.
numeroDescricoesFoldSuperespecificada = 0.
for anotacao in teste:
contexto = anotacao["caracteristicas"]["context"]
participante = str(anotacao["caracteristicas"]["trial"])
numeroExpressoesParticipante = 0
for annotation in treinamento:
if annotation["caracteristicas"]["trial"] == participante:
numeroExpressoesParticipante = numeroExpressoesParticipante + 1
A = ass.parse(anotacao["descricao"])
#random.shuffle(atributos)
#descricao = IncrementalAlgorithmRelational3(dominios[contexto], targets[contexto], preferencia[participante], False).run()
descricao = IncrementalAlgorithmRelational5(dominios[contexto], targets[contexto], preferencia[participante],
frequencia[participante], probabilidade, numeroExpressoesParticipante, False).run()
B = ass.parse(descricao, targets[contexto])
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1
acuraciaFold = acuraciaFold + 1
numeroDescricoes = numeroDescricoes + 1
numeroDescricoesFold = numeroDescricoesFold + 1
mediaDice.append(DICE)
mediaMasi.append(MASI)
mediaFoldDice.append(DICE)
mediaFoldMasi.append(MASI)
anotacao["dice_personalizado"] = DICE
anotacao["masi_personalizado"] = MASI
anotacao["algoritmo_personalizado"] = descricao
descricao = IncrementalAlgorithmRelationalOverspecified(dominios[contexto], targets[contexto], preferencia[participante],
frequencia[participante], probabilidade, numeroExpressoesParticipante, False).run()
B = ass.parse(descricao, targets[contexto])
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuraciaSuperespecificada = acuraciaSuperespecificada + 1
acuraciaFoldSuperespecificada = acuraciaFoldSuperespecificada + 1
numeroDescricoesSuperespecificada = numeroDescricoesSuperespecificada + 1
numeroDescricoesFoldSuperespecificada = numeroDescricoesFoldSuperespecificada + 1
mediaDiceSuperespecificada.append(DICE)
mediaMasiSuperespecificada.append(MASI)
mediaFoldDiceSuperespecificada.append(DICE)
mediaFoldMasiSuperespecificada.append(MASI)
anotacao["dice_personalizado_superespecificado"] = DICE
anotacao["masi_personalizado_superespecificado"] = MASI
anotacao["algoritmo_personalizado_superespecificado"] = descricao
# print anotacao["descricao"]
# print anotacao["algoritmo"]
# print anotacao["caracteristicas"]
# print anotacao["dice"]
# print anotacao["masi"]
# print 50 * "*"
print "Dice: ", num.mean(mediaFoldDice)
print "Masi: ",num.mean(mediaFoldMasi)
#.........这里部分代码省略.........
示例12: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(dominios, folds, atributos, targets, probabilidade):
diceGeral = []
masiGeral = []
acuraciaGeral = []
diceGeralSuperespecificada = []
masiGeralSuperespecificada = []
acuraciaGeralSuperespecificada = []
anotacoes = {}
print 50 * "*"
print 50 * "-"
print "Experimento Stars Global"
print 50 * "-"
for fold in folds:
print 50 * "-"
print "FOLD: ", fold
print 50 * "-"
[treinamento, teste] = toList(folds, fold)
anotacoes[fold] = {}
frequencia = countAttributeFrequency(treinamento)
lista_preferencia = getListaPreferencia(frequencia, atributos)
frequencia = countAttributeFrequency(treinamento)
# inclui os atributos nao mencionados no final da lista de preferencia
# random.shuffle(atributos)
# for atributo in atributos:
# if atributo not in lista_preferencia["target"]:
# lista_preferencia["target"].append(atributo)
#
# if atributo not in lista_preferencia["landmark"]:
# lista_preferencia["landmark"].append(atributo)
mediaDice = []
mediaMasi = []
mediaDiceSuperespecificada = []
mediaMasiSuperespecificada = []
acuracia = 0.
acuraciaSuperespecificada = 0.
numeroDescricoes = 0.
numeroDescricoesSuperespecificada = 0.
for anotacao in teste:
contexto = anotacao["caracteristicas"]["context"]
participante = str(anotacao["caracteristicas"]["trial"])
A = ass.parse(anotacao["descricao"])
descricao = IncrementalAlgorithmRelational5(dominios[contexto], targets[contexto], lista_preferencia, frequencia, probabilidade, len(treinamento), False).run()
B = ass.parse(descricao)
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1
numeroDescricoes = numeroDescricoes + 1
mediaDice.append(DICE)
mediaMasi.append(MASI)
anotacao["dice_global"] = DICE
anotacao["masi_global"] = MASI
anotacao["algoritmo_global"] = descricao
descricao = IncrementalAlgorithmRelationalOverspecified(dominios[contexto], targets[contexto], lista_preferencia, frequencia, probabilidade, len(treinamento), False).run()
B = ass.parse(descricao)
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuraciaSuperespecificada = acuraciaSuperespecificada + 1
numeroDescricoesSuperespecificada = numeroDescricoesSuperespecificada + 1
mediaDiceSuperespecificada.append(DICE)
mediaMasiSuperespecificada.append(MASI)
anotacao["dice_global_superespecificado"] = DICE
anotacao["masi_global_superespecificado"] = MASI
anotacao["algoritmo_global_superespecificado"] = descricao
anotacoes[fold][participante] = anotacao
# print anotacao["descricao"]
# print anotacao["algoritmo_global"]
# print anotacao["caracteristicas"]
# print anotacao["dice_global"]
# print anotacao["masi_global"]
# print 50 * "*"
print "DICE: ", num.mean(mediaDice)
print "MASI: ", num.mean(mediaMasi)
print "ACURACIA: ", acuracia / numeroDescricoes
#.........这里部分代码省略.........
示例13: run
# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import dice [as 别名]
def run(contextos, anotacoes, atributos):
frequencia = countAttributeFrequency(anotacoes)
lista_preferencia = {}
preferencia = {}
for participante in frequencia.keys():
if participante not in lista_preferencia.keys():
lista_preferencia[participante] = {}
lista_preferencia[participante]["target"] = []
lista_preferencia[participante]["landmark"] = []
preferencia[participante] = {}
preferencia[participante]["target"] = []
preferencia[participante]["landmark"] = []
while len(frequencia[participante]["target"]) != 0:
maximo = max(frequencia[participante]["target"].values())
for key in frequencia[participante]["target"].keys():
if frequencia[participante]["target"][key] == maximo:
lista_preferencia[participante]["target"].append(key)
del(frequencia[participante]["target"][key])
while len(frequencia[participante]["landmark"]) != 0:
maximo = max(frequencia[participante]["landmark"].values())
for key in frequencia[participante]["landmark"].keys():
if frequencia[participante]["landmark"][key] == maximo:
lista_preferencia[participante]["landmark"].append(key)
del(frequencia[participante]["landmark"][key])
for atributo in lista_preferencia[participante]["target"]:
if atributo in atributos:
preferencia[participante]["target"].append(atributo)
preferencia[participante]["landmark"] = []
for atributo in lista_preferencia[participante]["landmark"]:
if atributo in atributos:
preferencia[participante]["landmark"].append(atributo)
mediaDice = []
mediaMasi = []
acuracia = 0.
numeroDescricoes = 0.
frequencia = countAttributeFrequency(anotacoes)
for anotacao in anotacoes:
contexto = anotacao["caracteristicas"]["context"]
participante = str(anotacao["caracteristicas"]["trial"])
target = anotacao["caracteristicas"]["target"]
A = ass.parse(anotacao["descricao"])
numeroExpressoesParticipante = 0
for annotation in anotacoes:
if annotation["caracteristicas"]["trial"] == participante:
numeroExpressoesParticipante = numeroExpressoesParticipante + 1
#random.shuffle(atributos)
descricao = IncrementalAlgorithmRelational5(contextos[contexto], target, preferencia[participante],
frequencia[participante], 0.7, numeroExpressoesParticipante, True).run()
B = ass.parse(descricao)
DICE = ass.dice(A, B)
MASI = ass.masi(A, B)
if DICE == 1.0:
acuracia = acuracia + 1
numeroDescricoes = numeroDescricoes + 1
mediaDice.append(DICE)
mediaMasi.append(MASI)
anotacao["dice"] = DICE
anotacao["masi"] = MASI
anotacao["algoritmo"] = descricao
# print anotacao["descricao"]
# print anotacao["algoritmo"]
# print anotacao["caracteristicas"]
# print anotacao["dice"]
# print anotacao["masi"]
# print 100 * "*"
print "DICE: " + str(num.mean(mediaDice))
print "MASI: " + str(num.mean(mediaMasi))
print "Acuracia: " + str(acuracia / numeroDescricoes)
print "\n"