예제 #1
0
//MaisProvavel
int main()
{
    vector<string> atributos;
    atributos.push_back("word");
    atributos.push_back("tpos");
    atributos.push_back("np");

    CorpusMatriz objCorpus( atributos );
    objCorpus.carregarArquivo( "inputs/train.txt" );

    Classificador *objClass;
    MaisProvavel objMProv( LIM_FREQ_UNKNOWN );
    objClass = objMProv.executarTreinamento( objCorpus, ATRBT_ANALISADO );
    //objClass->carregarConhecimento( "inputs/conhecimentoMProv.txt" );

    CorpusMatriz objCorpusProva( atributos );
    objCorpusProva.carregarArquivo( "inputs/test.txt" );

    objClass->executarClassificacao( objCorpusProva, ATRBT_CLASSIFICADO );
    AvaliadorAcuracia objAvalAcur;

    printf( "Acuracia: %.2f%%\n", 100 * objAvalAcur.calcularDesempenho( objCorpusProva, ATRBT_ANALISADO, ATRBT_NOVO )[ 0 ] );
    objCorpusProva.gravarArquivo( "outputs/corpusGravado.txt" );
    objClass->gravarConhecimento( "outputs/conhecimentoMProv.txt" );
    delete objClass;

	return 0;
}
예제 #2
0
파일: main.cpp 프로젝트: naumazeredo/fama
int main()
{
    vector<string> atributos, classes, atributosTreino;
    int nConjExemplos, e, c0, c1, c, iResposta, iSaida, total;

    //carrega conjunto de dados
    CorpusMatriz objCorpus(atributos, ',', true, true);
    objCorpus.carregarArquivo( "../inputs/adult.data" );

    //indice do atributo a aprender
    iResposta = objCorpus.pegarPosAtributo("resposta");

    //quantidade de conjuntos de exemplos
    cout << (nConjExemplos = objCorpus.pegarQtdConjExemplos()) << " exemplos\n";

    //indica classes alvo
    classes.push_back("<=50K");
    classes.push_back(">50K");

    //calcula priori das classes
    c0 = c1 = total = 0;
    for (c = 0; c < nConjExemplos; c++)
        for (e = 0; e < objCorpus.pegarQtdExemplos(c); e++) {
            if (objCorpus.pegarIndice(classes[0]) == objCorpus.pegarValor(c, e, iResposta))
                c0++;
            else
                c1++;
            total++;
        }

    cout << 100.*c0/total << " / " << 100.*c1/total << endl;
    atributos = objCorpus.pegarAtributos();

    //remove atributos que nao devem ser utilizados pelo treinamento
    for (unsigned int i=0; i < atributos.size(); i++)
        if (atributos[i]!="resposta")// && atributos[i]!="workclass" && atributos[i]!="fnlwgt")
            atributosTreino.push_back(atributos[i]);

    DecisionStump objStump(atributosTreino, classes);
    AvaliadorAcuracia objAvalAcur;
    ValidadorKDobras objValidador(objAvalAcur, 10);
    iSaida = objCorpus.criarAtributo("saida", "O");

    vector< vector< float > > v = objValidador.executarExperimento(objStump, objCorpus, iResposta, iSaida);
    float media = 0;
    for (c=0; c<10; c++) {
        cout << c << " - " << v[c][0] << endl;
        media +=v[c][0];
    }
    cout << "*" << media/10 << endl;

    Classificador *objClass = objStump.executarTreinamento(objCorpus, iResposta);
    objClass->executarClassificacao(objCorpus, iSaida);
    cout << objClass->descricaoConhecimento();
    printf( "Acuracia: %.2f%%\n", 100 * objAvalAcur.calcularDesempenho( objCorpus,
            iResposta, iSaida)[0]);

    delete objClass;
    return 0;
}
예제 #3
0
파일: main.cpp 프로젝트: duartejulio/fama
int main()
{
    vector<string> atributos, classes;
    int atributo, novoatributo, c;
    Classificador *cl;//,*cl2;
    AvaliadorAcuracia objAvalAcur;

    float media;

    srand(time(NULL));

    //carrega conjunto de dados
    CorpusMatriz objCorpus(atributos, ',', true, true);
    objCorpus.carregarArquivo( "../../../inputs/adult.data.medium" );
    atributo = objCorpus.pegarPosAtributo("resposta");

    classes.push_back("<=50K");
    classes.push_back(">50K");

    atributos = objCorpus.pegarAtributos();
    atributos.pop_back();

    //treina
    DecisionStump stump(atributos, classes);
    TreinadorAdaboost adab(stump, classes, 30, 0.01, false);

    novoatributo = objCorpus.criarAtributo("me");

    cl = adab.executarTreinamento(objCorpus, atributo);
    cout << cl->descricaoConhecimento() << endl;
//    cl->gravarConhecimento("xpto");

//    cl2 = new ClassificadorMaisEsperto;
//    cl->carregarConhecimento("xpto");

    //classifica

//    cl2->executarClassificacao(objCorpus, novoatributo);
    cl->executarClassificacao(objCorpus, novoatributo);

    objCorpus.gravarArquivo("#testeout.txt");

    //avalia
    cout << 100 * objAvalAcur.calcularDesempenho(objCorpus, atributo, novoatributo)[0] << "%\n";

    //faz experimento
    int ndobras = 10;
    ValidadorKDobras objValidador(objAvalAcur, ndobras, false);
    vector< vector< float > > v;
    try{
        v = objValidador.executarExperimento(adab, objCorpus, atributo, novoatributo);
    }
    catch(string s){
        cout << "*" << s << endl;
        return 1;
    }
    catch(...){
        cout << "Erro desconhecido" << endl;
        return 2;
    }
    media = 0;
    for (c=0;c<ndobras;c++){
        cout << c << " - " << 100.*v[c][0] << "%\n";
        media += v[c][0];
    }
    cout << "*" << media/ndobras << "\n";

    return 0;
}
예제 #4
0
Classificador* TreinadorAdaboost::executarTreinamento( Corpus &corpus, int atributo ){

    Classificador *cl;
    double beta, acertos, erros, sumdist;
    vector <double> alphas;
    vector<Classificador*> classificadores;

    unsigned i, atributoTemporario, c, e, nConjExemplos = corpus.pegarQtdTotalExemplos(), nExemplos;
    vector<double> dist(nConjExemplos, 1.0/nConjExemplos);
    vector<bool> errado(nConjExemplos);

    atributoTemporario = corpus.criarAtributo("adab");

    for (i = 0; i < iterations; i++){
        fill_n(errado.begin(), nConjExemplos, false);

        base.ajustarDistribuicao(dist);
        cl = base.executarTreinamento(corpus, atributo);
        cl->executarClassificacao(corpus, atributoTemporario);

        //calcula erro, generalizar para vários exemplos por conjunto de exemplo
        acertos = erros = 0;
        for (c=0;c<nConjExemplos;c++){
            nExemplos = corpus.pegarQtdExemplos(c);
            for (e=0; e<nExemplos; e++){
                if ((corpus.pegarValor(c,e,atributo)!=corpus.pegarValor(c,e,atributoTemporario))){
                    errado[c] = true;
                    break;
                }
            }
            if (errado[c])
                erros += dist[c];
            else
                acertos += dist[c];
        }
        beta = acertos/erros;

        //cout << i << "-" << beta << endl;

        sumdist = 0.0;
        for (c=0;c<nConjExemplos;c++){
            if (errado[c])
                dist[c] *= beta;
            sumdist += dist[c];
        }

        for (c=0;c<nConjExemplos;c++)
            dist[c] /= sumdist;


        classificadores.push_back(cl);
        alphas.push_back(.5*log(beta));

        if (alphas[i] < minalpha)
            break;
    }

    corpus.removerAtributo("adab");

    return new ClassificadorAdaboost(classes,classificadores,alphas);
}