Python Assurance.parse方法代码示例

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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
        

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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"

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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"

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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"

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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 = {}
#.........这里部分代码省略.........

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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]
#.........这里部分代码省略.........

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [as 别名]
def parseSVMInput(anotacoes, featureVector, participantes, frequencias, incluiParticipante = True):
    input = []
    atributos = ["type", "colour", "hpos", "vpos", "near", "left", "right", "below", "above"]
    
    for participante in anotacoes:
        for anotacao in anotacoes[participante]:
            classes = {}
            vetor = []
            participante = anotacao["caracteristicas"]["trial"]
            contexto = anotacao["caracteristicas"]["context"]
            target = anotacao["caracteristicas"]["target"]
            
            if incluiParticipante == True:
                vetor.append(int(participante))
                
                genero = anotacao["caracteristicas"]["genre"]
                if genero == "m":
                    vetor.append(0)
                else:
                    vetor.append(1)
                    
                idade = int(anotacao["caracteristicas"]["age"])
                if idade <= 20:
                    vetor.append(0)
                elif idade > 20 and idade <= 25:
                    vetor.append(1)
                elif idade >= 26 and idade <= 30:
                    vetor.append(2)
                elif idade > 30 and idade <= 40:
                    vetor.append(3)
                elif idade > 40 and idade <= 50:
                    vetor.append(4)
                elif idade > 50 and idade <= 60:
                    vetor.append(5)
                else:
                    vetor.append(6)
                
                for atributo in atributos:
                    if atributo in frequencias[participante]["target"].keys():
                        vetor.append(frequencias[participante]["target"][atributo])
                    else:
                        vetor.append(0)
                                   
                for atributo in atributos:
                    if atributo in frequencias[participante]["landmark"].keys():
                        vetor.append(frequencias[participante]["landmark"][atributo])
                    else:
                        vetor.append(0)
            
                vetor.append(participantes[participante]["overspecification"])
                vetor.append(participantes[participante]["tg_description_size"])
                vetor.append(participantes[participante]["lm_description_size"])
                vetor.append(participantes[participante]["lm2_description_size"])
                vetor.append(participantes[participante]["num_relations"])
                vetor.append(participantes[participante]["overspecified_mean"])
                vetor.append(participantes[participante]["underspecified_mean"])
                vetor.append(participantes[participante]["minimal_mean"])
                      
            if featureVector[contexto]["relation"] == "none":
                vetor.append(0)
            elif featureVector[contexto]["relation"] == "horizontal":
                vetor.append(0)
            else:
                vetor.append(1)
            
            vetor.append(featureVector[contexto]["num_tg_col"])
            vetor.append(featureVector[contexto]["num_lm_col"])
            vetor.append(featureVector[contexto]["num_tg_type"])
            vetor.append(featureVector[contexto]["num_lm_type"])
            vetor.append(featureVector[contexto]["tg_lm_col"])
            vetor.append(featureVector[contexto]["tg_lm_type"])
            
            vetor.append(featureVector[contexto]["dp_tg_col"])
            vetor.append(featureVector[contexto]["dp_lm_col"])
            vetor.append(featureVector[contexto]["dp_tg_type"])
            vetor.append(featureVector[contexto]["dp_lm_type"])
            vetor.append(featureVector[contexto]["dp_tg_hpos"])
            vetor.append(featureVector[contexto]["dp_lm_hpos"])
            vetor.append(featureVector[contexto]["dp_tg_vpos"])
            vetor.append(featureVector[contexto]["dp_lm_vpos"])
      
            vetor.append(featureVector[contexto]["saliency_col"])
            vetor.append(featureVector[contexto]["saliency_type"])
            vetor.append(featureVector[contexto]["saliency_hpos"])
            vetor.append(featureVector[contexto]["saliency_vpos"])
            
            if "type" in anotacao["descricao"][target].keys():
                classes["type"] = 1
            else:
                classes["type"] = 0
            
            if "colour" in anotacao["descricao"][target].keys():
                classes["colour"] = 1
            else:
                classes["colour"] = 0
                
            if "hpos" in anotacao["descricao"][target].keys():
                classes["hpos"] = 1
            else:
                classes["hpos"] = 0
#.........这里部分代码省略.........

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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)
#.........这里部分代码省略.........

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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
#.........这里部分代码省略.........

# 需要导入模块: import Assurance [as 别名]
# 或者: from Assurance import parse [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"