2011-05-17 20:24:18 +00:00
|
|
|
#include "interface.H"
|
|
|
|
extern PPRFA A;
|
|
|
|
extern Sample S;
|
|
|
|
extern int nb_tours;
|
|
|
|
extern float epsprime;
|
|
|
|
extern bool verbose;
|
|
|
|
void genere_aleatoire_unique()
|
|
|
|
{
|
|
|
|
int nbetats;
|
|
|
|
int nblettres;
|
|
|
|
int numgraphe;
|
|
|
|
int nb_succ, nb_init, nb_term;
|
|
|
|
PFA A;
|
|
|
|
|
|
|
|
cout << "Nombre d'Ètat : ";
|
|
|
|
cin >> nbetats;
|
|
|
|
cout << "Nombre de lettres : ";
|
|
|
|
cin >> nblettres;
|
|
|
|
cout << "Numero du graphe : ";
|
|
|
|
cin >> numgraphe;
|
|
|
|
cout << "nombre de successeurs par couple (etat-lettre) : ";
|
|
|
|
cin >> nb_succ;
|
|
|
|
cout << "nombre maximal d'etats initiaux : ";
|
|
|
|
cin >> nb_init;
|
|
|
|
cout << "nombre maximal d'etats terminaux : ";
|
|
|
|
cin >> nb_term;
|
|
|
|
A.becomeRandomMax (nbetats, nblettres, numgraphe, nb_succ, nb_init, nb_term);
|
|
|
|
string fichier_ps = "_tmp.ps";
|
|
|
|
string fichier_tmp = "_temporary_file";
|
|
|
|
export_to_pdf (A, fichier_ps, fichier_tmp);
|
|
|
|
show_ps (fichier_ps);
|
|
|
|
|
|
|
|
if (A.isPFA ())
|
|
|
|
{
|
|
|
|
if (A.isPRFA (true))
|
|
|
|
cout << "is PRFA" << endl;
|
|
|
|
else
|
|
|
|
cout << "is PFA" << endl;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cout << "not PFA" << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void proportion_PRFA()
|
|
|
|
{
|
|
|
|
//------------ Proportion de PRFA -----------
|
|
|
|
int max_nb_states; // max number of states
|
|
|
|
int nb_try; // number of tests
|
|
|
|
map < int, int >Tableau;
|
|
|
|
map < int, int >nbPFA;
|
|
|
|
int i; // taille du tableau
|
|
|
|
int j; // nombre d'essais
|
|
|
|
int nb_moy_succ; // nombre moyen de successeurs
|
|
|
|
unsigned int taille_auto; // taille de l'automate
|
|
|
|
|
|
|
|
cout << "Nb d'Ètat maximal : ";
|
|
|
|
cin >> max_nb_states;
|
|
|
|
cout << "Nb de PFAs par taille : ";
|
|
|
|
cin >> nb_try;
|
|
|
|
cout << "Nb moyen de successeurs par Ètat et par lettre : ";
|
|
|
|
cin >> nb_moy_succ;
|
|
|
|
for (i = 1; i <= max_nb_states; ++i)
|
|
|
|
{
|
|
|
|
nbPFA[i]=0;
|
|
|
|
Tableau[i]=0;
|
|
|
|
cout << "\ni = " << i << endl;
|
|
|
|
for (j = 0; j < nb_try; ++j)
|
|
|
|
{
|
|
|
|
A.becomeRandomMax(i,2,0,nb_moy_succ, 1, i);
|
2016-09-24 12:08:58 +00:00
|
|
|
taille_auto = (int) A.size ();
|
2011-05-17 20:24:18 +00:00
|
|
|
if (taille_auto == (unsigned int) i)
|
|
|
|
{
|
|
|
|
if (A.isPFA ())
|
|
|
|
{
|
|
|
|
++nbPFA[taille_auto];
|
|
|
|
if (A.isPRFA (false))
|
|
|
|
{
|
|
|
|
++Tableau [taille_auto];
|
|
|
|
cout << "R" << taille_auto << ",";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cout << "P" << taille_auto << ",";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cout << "X";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// compte rendu
|
|
|
|
cout << "Nb d'Ètats\t% de PRFA\t(nb d'essais)" << endl;
|
|
|
|
map < int, int >::iterator t;
|
|
|
|
map < int, int >::iterator nbPFAi;
|
|
|
|
for (t = Tableau.begin (); t != Tableau.end (); ++t)
|
|
|
|
{
|
|
|
|
if (nbPFA[t->first] != 0)
|
|
|
|
{
|
|
|
|
cout << t->first << "\t\t" << (t->second * 100) /
|
|
|
|
nbPFA[t->first] << "%\t(" << t->
|
|
|
|
second << "/" << nbPFA[t->first] << ")" << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//---------- Fin de la procedure de test de la proportion de PRFA
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void prefixialisa_echantillon()
|
|
|
|
{
|
|
|
|
string ficin, ficout;
|
|
|
|
cout << "Entrez le fichier echantillon : ";
|
|
|
|
cin >> ficin;
|
|
|
|
cout << "Entrez le nom du fichier de sortie : ";
|
|
|
|
cin >> ficout;
|
|
|
|
cout << "load en cours..." << endl;
|
|
|
|
S.load (ficin);
|
|
|
|
cout << "save en cours..." << endl;
|
|
|
|
S.prefixialise();
|
|
|
|
S.save (ficout);
|
|
|
|
cout << "Voil‡ c'est fini" << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Choix_cysteines()
|
|
|
|
{
|
|
|
|
// = 1 ===================== on entre les noms des fichiers
|
|
|
|
string nom_base_pos;
|
|
|
|
cout << "Veuillez entrer les noms des fichiers de pfa,\n";
|
|
|
|
cout << "de l'echantillon positif associÈ,\n";
|
|
|
|
cout << "de l'Èchantillon nÈgatif associÈ,\n";
|
|
|
|
cout << "et enfin le nom de l'Èchantillon test associÈ.\n\n";
|
|
|
|
|
|
|
|
cout << "Finissez en entrant le nom ." << endl;
|
|
|
|
;
|
|
|
|
|
|
|
|
map < int, PPRFA > Modele;
|
|
|
|
map < int, Sample > PosSample;
|
|
|
|
map < int, Sample > NegSample;
|
|
|
|
map < int, Sample > TestSample;
|
|
|
|
string nom;
|
|
|
|
Sample S;
|
|
|
|
PPRFA A;
|
|
|
|
cout << "Nom du fichier pfa : ";
|
|
|
|
cin >> nom;
|
|
|
|
int i;
|
|
|
|
i = -1;
|
|
|
|
while (nom != ".")
|
|
|
|
{
|
|
|
|
++i;
|
|
|
|
A.load (nom);
|
|
|
|
Modele[i] = A;
|
|
|
|
cout << "Èchantillon positif associe : ";
|
|
|
|
cin >> nom;
|
|
|
|
S.load (nom);
|
|
|
|
PosSample[i] = S;
|
|
|
|
cout << "Èchantillon negatif associe : ";
|
|
|
|
cin >> nom;
|
|
|
|
S.load (nom);
|
|
|
|
NegSample[i] = S;
|
|
|
|
cout << "Èchantillon test associe : ";
|
|
|
|
cin >> nom;
|
|
|
|
S.load (nom);
|
|
|
|
TestSample[i] = S;
|
|
|
|
cout << "\nNom du fichier pfa : ";
|
|
|
|
cin >> nom;
|
|
|
|
}
|
|
|
|
|
|
|
|
// = 2 =============== on calcule les moyennes et ecart-types
|
|
|
|
map < int, float >moyenne_pos;
|
|
|
|
map < int, float >ecartype_pos;
|
|
|
|
map < int, float >moyenne_neg;
|
|
|
|
map < int, float >ecartype_neg;
|
|
|
|
Dictionnaire dico;
|
|
|
|
|
|
|
|
map < int, float >probabilite_pos;
|
|
|
|
map < int, float >probabilite_neg;
|
|
|
|
map < int, float >::const_iterator prob_it;
|
|
|
|
map < int, float >decalage_pos;
|
|
|
|
map < int, float >decalage_neg;
|
|
|
|
Sample::const_iterator w;
|
|
|
|
|
|
|
|
int j;
|
|
|
|
float min;
|
|
|
|
float val;
|
|
|
|
for (i = 0; i < (int) Modele.size (); ++i)
|
|
|
|
{ // pour tous les modËles
|
|
|
|
|
|
|
|
Modele[i].lisse();
|
|
|
|
|
|
|
|
// 1a - on calcule la probabilite minimale les mots positifs
|
|
|
|
dico = PosSample[i].dictionnaire ();
|
|
|
|
j=0;
|
|
|
|
min = 1;
|
|
|
|
for (w = PosSample[i].begin ();
|
|
|
|
w != PosSample[i].end (); ++w)
|
|
|
|
{
|
|
|
|
probabilite_pos[j] = Modele[i].plog (w->first, &dico);
|
|
|
|
if (probabilite_pos[j] < min)
|
|
|
|
min = probabilite_pos[j];
|
|
|
|
++j;
|
|
|
|
}
|
|
|
|
decalage_pos[i] = min;
|
|
|
|
|
|
|
|
// 1b - on calcule la probabilite minimale les mots negatifs
|
|
|
|
dico = NegSample[i].dictionnaire ();
|
|
|
|
j=0;
|
|
|
|
min = 1;
|
|
|
|
for (w = NegSample[i].begin (); w != NegSample[i].end (); ++w)
|
|
|
|
{
|
|
|
|
probabilite_neg[j] = Modele[i].plog (w->first, &dico);
|
|
|
|
if (probabilite_neg[j] < min)
|
|
|
|
min = probabilite_neg[j];
|
|
|
|
++j;
|
|
|
|
}
|
|
|
|
decalage_neg[i]= min;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (decalage_neg[i]<decalage_pos[i])
|
|
|
|
decalage_pos[i]=decalage_neg[i];
|
|
|
|
else
|
|
|
|
decalage_neg[i]=decalage_pos[i];
|
|
|
|
|
|
|
|
// --- on a calcule le decalage ---
|
|
|
|
|
|
|
|
// 2 - on calcule la moyenne pour les mots positifs
|
|
|
|
moyenne_pos[i] = 0;
|
|
|
|
for (prob_it = probabilite_pos.begin() ;
|
|
|
|
prob_it != probabilite_pos.end(); ++prob_it)
|
|
|
|
{
|
|
|
|
moyenne_pos[i] += exp (prob_it->second - decalage_pos[i]);
|
|
|
|
}
|
|
|
|
moyenne_pos[i] /= PosSample[i].size();
|
|
|
|
|
|
|
|
// 3 - on calcule l'ecartype pour les mots positifs
|
|
|
|
ecartype_pos[i] = 0;
|
|
|
|
for (prob_it = probabilite_pos.begin() ;
|
|
|
|
prob_it != probabilite_pos.end() ; ++prob_it)
|
|
|
|
{
|
|
|
|
ecartype_pos[i] +=
|
|
|
|
pow (moyenne_pos[i] - exp (prob_it->second - decalage_pos[i]), 2);
|
|
|
|
}
|
|
|
|
ecartype_pos[i] /= PosSample[i].size();
|
|
|
|
ecartype_pos[i] = sqrt(ecartype_pos[i]);
|
|
|
|
|
|
|
|
// Maintenant, moyenne_pos[i] contient la valeur moyenne de la probabilite
|
|
|
|
// des mots positifs et ecartype_pos[i] contient l'ecart-type des mots pos.
|
|
|
|
|
|
|
|
// puis pareil pour les nÈgatifs
|
|
|
|
|
|
|
|
// 2 - on calcule la moyenne
|
|
|
|
moyenne_neg[i] = 0;
|
|
|
|
for (prob_it = probabilite_neg.begin() ;
|
|
|
|
prob_it != probabilite_neg.end(); ++prob_it)
|
|
|
|
{
|
|
|
|
moyenne_neg[i] += exp (prob_it->second - decalage_neg[i]);
|
|
|
|
}
|
|
|
|
moyenne_neg[i] /= NegSample[i].size();
|
|
|
|
|
|
|
|
// 3 - on calcule l'ecartype pour les mots positifs
|
|
|
|
ecartype_neg[i] = 0;
|
|
|
|
for (prob_it = probabilite_neg.begin() ;
|
|
|
|
prob_it != probabilite_neg.end() ; ++prob_it)
|
|
|
|
{
|
|
|
|
ecartype_neg[i] +=
|
|
|
|
pow (moyenne_neg[i] - exp (prob_it->second - decalage_neg[i]), 2);
|
|
|
|
}
|
|
|
|
ecartype_neg[i] /= NegSample[i].size();
|
|
|
|
ecartype_neg[i] = sqrt( ecartype_neg[i] );
|
|
|
|
|
|
|
|
// on a fini de calculer les moyennes et les ecartype pour le modele i
|
|
|
|
|
|
|
|
cout << "µ pos : " << moyenne_pos[i];
|
|
|
|
cout << ", sigma pos : " << ecartype_pos[i];
|
|
|
|
cout << ", decalage pos : " << decalage_pos[i] << "\n";
|
|
|
|
cout << "µ neg : " << moyenne_neg[i];
|
|
|
|
cout << ", sigma neg : " << ecartype_neg[i];
|
|
|
|
cout << ", decalage neg : " << decalage_neg[i] << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
// = 3 ==================================== evaluation
|
|
|
|
|
|
|
|
double p1, p2;
|
|
|
|
bool res;
|
|
|
|
map < int, float >probapos;
|
|
|
|
Word u;
|
|
|
|
res = 0;
|
|
|
|
i = 0;
|
|
|
|
for (i = 0; i < (int) Modele.size (); ++i)
|
|
|
|
{
|
|
|
|
u = TestSample[i].begin ()->first;
|
|
|
|
dico = TestSample[i].dictionnaire ();
|
|
|
|
val = Modele[i].plog (u, &dico);
|
|
|
|
cout << "val = " << exp( val - decalage_pos[i] ) << endl;
|
|
|
|
if (moyenne_pos[i] > moyenne_neg[i])
|
|
|
|
{
|
|
|
|
p1 = fonction (exp (val - decalage_pos[i]), moyenne_pos[i], ecartype_pos[i]); // ECRIRE fonction
|
|
|
|
p2 = fonction (moyenne_neg[i], exp (val - decalage_neg[i]) , ecartype_neg[i]); // !!!!!!!!!!!!!!!
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p1 = fonction (moyenne_pos[i], exp (val - decalage_pos[i]), ecartype_pos[i]); // ECRIRE fonction
|
|
|
|
p2 = fonction (exp (val - decalage_neg[i]), moyenne_neg[i] , ecartype_neg[i]); // !!!!!!!!!!!!!!!
|
|
|
|
}
|
|
|
|
cout << "p_pos = " << p1;
|
|
|
|
cout << ", p_neg = " << p2;
|
|
|
|
probapos[i] = (p1 + (1 - p2)) / 2; // ???????
|
|
|
|
cout << ", probapos = " << probapos[i] << endl;
|
|
|
|
}
|
|
|
|
float probaposgenerale=0;
|
|
|
|
for (i=0 ; i< (int) probapos.size() ; ++i)
|
|
|
|
probaposgenerale += probapos[i];
|
|
|
|
probaposgenerale /= i;
|
|
|
|
cout << "probabilite d'etre positif = " << probaposgenerale << endl;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Apprentissage_unique()
|
|
|
|
{
|
|
|
|
string ficech;
|
|
|
|
cout << "Veuillez entrer le nom du fichier contenant l'echantillon : ";
|
|
|
|
cin >> ficech;
|
|
|
|
Sample S;
|
|
|
|
if (!OK (S.load (ficech.c_str ())))
|
|
|
|
{
|
|
|
|
cerr << "impossible d'ouvrir " << ficech << endl;
|
|
|
|
throw 5;
|
|
|
|
}
|
|
|
|
|
|
|
|
PPRFA A;
|
|
|
|
string reponse;
|
|
|
|
unsigned int seuil;
|
|
|
|
string str;
|
|
|
|
float tmp;
|
|
|
|
float precision;
|
2016-09-24 12:08:58 +00:00
|
|
|
T_ModeReturn moderet=::begin;
|
2011-05-17 20:24:18 +00:00
|
|
|
T_ModeEpsilon modeeps=epsfixed;
|
|
|
|
|
|
|
|
int max_etats=INT_MAX;
|
|
|
|
cout << "Les parametres necessaires a l'apprentissage sont : \n";
|
|
|
|
while (reponse != "0")
|
|
|
|
{
|
|
|
|
cout << "1 - La precision .................. : "
|
|
|
|
<< precision << "\n";
|
|
|
|
cout << "2 - Le mode de retour ............. : "
|
2016-09-24 12:08:58 +00:00
|
|
|
<< (moderet==::begin?"begin":"end") << "\n";
|
2011-05-17 20:24:18 +00:00
|
|
|
cout << "3 - Le mode de gestion de epsilon . : "
|
|
|
|
<< (modeeps==epsfixed?"epsfixed":
|
|
|
|
(modeeps==variable?"variable":"word_variable"))
|
|
|
|
<< "\n";
|
|
|
|
cout << "4 - Seuil de suppression des aretes : "
|
|
|
|
<< epsprime << "\n";
|
|
|
|
cout << "5 - Verbose ....................... : "
|
|
|
|
<< verbose << "\n";
|
|
|
|
cout << "6 - La taille maximale de la cible : "
|
|
|
|
<< max_etats << "%\n";
|
|
|
|
cout << "7 - Nombre de successeurs par mot : "
|
|
|
|
<< seuil << "\n";
|
|
|
|
cout << "\n";
|
|
|
|
cout << "0 - Debut de l'apprentissage\n";
|
|
|
|
cout << "\n";
|
|
|
|
cout << "Votre choix : ";
|
|
|
|
cin >> reponse ;
|
|
|
|
|
|
|
|
if (reponse == "1")
|
|
|
|
{ // precision
|
|
|
|
cout << "nouvelle precision : ";
|
|
|
|
cin >> precision;
|
|
|
|
}
|
|
|
|
else if (reponse == "2")
|
|
|
|
{ // mode de retour
|
|
|
|
cout << "mode de retour (begin|end|b|e) : ";
|
|
|
|
cin >> str;
|
|
|
|
if ((str=="end") || (str == "e"))
|
2016-09-24 12:08:58 +00:00
|
|
|
moderet=::end;
|
2011-05-17 20:24:18 +00:00
|
|
|
else
|
2016-09-24 12:08:58 +00:00
|
|
|
moderet=::begin;
|
2011-05-17 20:24:18 +00:00
|
|
|
}
|
|
|
|
else if (reponse == "3")
|
|
|
|
{ // mode de gestion de epsilon
|
|
|
|
cout << "mode de gestion d'epsilon (fixed|variable|word_variable|f|v|w) : ";
|
|
|
|
cin >> str;
|
|
|
|
if ((str == "word_variable") || (str == "w"))
|
|
|
|
{
|
|
|
|
modeeps=word_variable;
|
|
|
|
}
|
|
|
|
else if ((str == "variable") || (str == "v"))
|
|
|
|
{
|
|
|
|
modeeps=variable;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
modeeps=epsfixed;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (reponse == "4")
|
|
|
|
{ //seuil de suppression des aretes
|
|
|
|
cout << "seuil de suppression des aretes ([0;1]) : ";
|
|
|
|
cin >> tmp;
|
|
|
|
if ((tmp >=0) && (tmp <= 100))
|
|
|
|
epsprime = tmp;
|
|
|
|
}
|
|
|
|
else if (reponse == "5")
|
|
|
|
{ // verbose
|
|
|
|
verbose = !verbose;
|
|
|
|
}
|
|
|
|
else if (reponse == "6")
|
|
|
|
{ // nombre maximal d'etats
|
|
|
|
cout << "Nombre maximal d'etats : ";
|
|
|
|
cin >> max_etats;
|
|
|
|
}
|
|
|
|
else if (reponse == "7")
|
|
|
|
{ // nombre de successeur par mots
|
|
|
|
cout << "Nombre de successeurs necessaires par mot : ";
|
|
|
|
cin >> seuil;
|
|
|
|
}
|
|
|
|
else if (reponse == "0")
|
|
|
|
{}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cout << "Choix inconnu" << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
A.DEES (nonconstrained, S, precision, epsprime, verbose, moderet, modeeps, max_etats, seuil);
|
|
|
|
string ficffaA="test/A.ffa";
|
|
|
|
if (verbose)
|
|
|
|
cout << "saving A in " << ficffaA << endl;
|
|
|
|
A.save (ficffaA);
|
|
|
|
// affichage de l'automate
|
|
|
|
string ficpsA="test/A.ps";
|
|
|
|
string ficdotA="test/A.dot";
|
|
|
|
export_to_pdf (A, ficpsA, ficdotA);
|
|
|
|
show_ps (ficpsA);
|
|
|
|
}
|
|
|
|
|
|
|
|
void makePTA()
|
|
|
|
{
|
|
|
|
string ficech;
|
|
|
|
PPRFA A;
|
|
|
|
Sample S;
|
|
|
|
cout << "Donnez le fichier contenant l'echantillon : ";
|
|
|
|
cin >> ficech;
|
|
|
|
S.load(ficech);
|
|
|
|
A.becomePrefixTree(S);
|
|
|
|
string ficpsA = "test/tmp.ps";
|
|
|
|
string ficdotA= "test/tmp.dot";
|
|
|
|
export_to_pdf(A,ficpsA, ficdotA);
|
|
|
|
show_ps(ficpsA);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TST_FD_BD() {
|
|
|
|
string ficpfa;
|
|
|
|
cout << "Donnez le fichier contenant le PFA : ";
|
|
|
|
cin >> ficpfa;
|
|
|
|
A.load(ficpfa);
|
|
|
|
|
|
|
|
Word w;
|
|
|
|
cout << "Donnez un mot : ";
|
|
|
|
cin >> w;
|
|
|
|
|
|
|
|
list<PreciseSFunc> F, B;
|
|
|
|
A.logforward(F,w);
|
|
|
|
A.logbackward(B,w);
|
|
|
|
|
|
|
|
list<PreciseSFunc>::const_iterator f;
|
|
|
|
list<PreciseSFunc>::const_reverse_iterator b;
|
|
|
|
PreciseSFunc::const_iterator x, y;
|
|
|
|
cout << "P(" << w << ")=" << A.p(w) << endl;
|
|
|
|
for (f = F.begin(), b=B.rbegin() ; f != F.end() ; ++f, ++b) {
|
|
|
|
for (x=f->begin() ; x != f->end() ; ++x) {
|
|
|
|
cout << "F[" << x->first << "]=" << exp(x->second) << ", ";
|
|
|
|
}
|
|
|
|
cout << "\n";
|
|
|
|
for (y=b->begin() ; y != b->end() ; ++y) {
|
|
|
|
cout << "B[" << y->first << "]=" << exp(y->second) << ", ";
|
|
|
|
}
|
|
|
|
cout << "\n\t----" << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void TST1() {
|
|
|
|
S.load("sample");
|
|
|
|
SFunc solution;
|
|
|
|
WordSFunc XR;
|
|
|
|
XR[""]=1;
|
|
|
|
XR["a"]=2;
|
|
|
|
XR["b"]=3;
|
|
|
|
solution[1]=0.5;
|
|
|
|
solution[2]=0.5;
|
|
|
|
A.becomePrefixTree(S);
|
|
|
|
SFunc Iota,Tau;
|
|
|
|
A.allStates(Tau);
|
|
|
|
TransitionFunction T;
|
|
|
|
A.allTransitions(T);
|
|
|
|
A.BaumWelch(S,T,Iota,Tau,10 , false);
|
|
|
|
float x = S.AutoLikelihood();
|
|
|
|
float y = A.Likelihood(S);
|
|
|
|
A.save("test/res.ffa");
|
|
|
|
cout << S.size() << " "<< x << " "<< y << " :: " << (x-y)/S.size() << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TST(){
|
|
|
|
string entree;
|
|
|
|
string sortie;
|
|
|
|
cout << "Echantillon d'entrée : ";
|
|
|
|
cin >> entree;
|
|
|
|
cout << "Echantillon de sortie : ";
|
|
|
|
cin >> sortie;
|
|
|
|
Sample S;
|
|
|
|
S.load(entree);
|
|
|
|
S.save(sortie);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TST4() {
|
|
|
|
SFunc solution;
|
|
|
|
SFunc Iota,Tau;
|
|
|
|
TransitionFunction T;
|
|
|
|
Transition t1,t2;
|
|
|
|
float x, y, x1, x2, y1, y2;
|
|
|
|
float xsum, val;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
S.load("sample");
|
|
|
|
solution[1]=0.5;
|
|
|
|
solution[2]=0.5;
|
|
|
|
S.prefixialise();
|
|
|
|
int nb_sucb=S["b"];
|
|
|
|
|
|
|
|
cout << "prefixialisation..." << endl;
|
|
|
|
S.deprefixialise();
|
|
|
|
|
|
|
|
cout << "becomePrefixTree..." << endl;
|
|
|
|
A.becomePrefixTree(S);
|
|
|
|
A.save("test/pta");
|
|
|
|
|
|
|
|
cout << "becomeQPFT..." << endl;
|
|
|
|
A.becomeQuasiPrefixTree(S,"b",solution);
|
|
|
|
A.save("test/qpta");
|
|
|
|
|
|
|
|
A.allStates(Tau);
|
|
|
|
A.allTransitions(T);
|
|
|
|
|
|
|
|
t1.qdep=t2.qdep=1;
|
|
|
|
t1.a=t2.a='b';
|
|
|
|
t1.qarr=1;
|
|
|
|
t2.qarr=2;
|
|
|
|
|
|
|
|
|
|
|
|
A.BaumWelch(S,T,Iota,Tau,30, false);
|
|
|
|
x1=T[t1]; x2=T[t2];
|
|
|
|
xsum = x1+x2;
|
|
|
|
x1 /= xsum;
|
|
|
|
x2 /= xsum;
|
|
|
|
|
|
|
|
A.BaumWelch(S,T,Iota,Tau,1, false);
|
|
|
|
y1=T[t1]; y2=T[t2];
|
|
|
|
xsum = y1+y2;
|
|
|
|
y1 /= xsum;
|
|
|
|
y2 /= xsum;
|
|
|
|
|
|
|
|
val=abs(x1-y1)+abs(x2 - y2);
|
|
|
|
|
|
|
|
i=20;
|
|
|
|
while ((val > 0.001) && (--i != 0)) {
|
|
|
|
cout << ".";
|
|
|
|
x1=y1; x2=y2;
|
|
|
|
A.BaumWelch(S,T,Iota,Tau,1, true);
|
|
|
|
y1=T[t1]; y2=T[t2];
|
|
|
|
xsum = y1+y2;
|
|
|
|
y1 /= xsum;
|
|
|
|
y2 /= xsum;
|
|
|
|
val=abs(x1-y1)+abs(x2 - y2);
|
|
|
|
}
|
|
|
|
A.save("test/qptafinal.ffa");
|
|
|
|
|
|
|
|
A.save("test/res.ffa");
|
|
|
|
x = S.AutoLikelihood();
|
|
|
|
y = A.Likelihood(S);
|
|
|
|
val=abs((y-x)/float(S.size()));
|
|
|
|
cout << S.size() << " "<< x << " "<< y << " :: " << val << " " << nb_sucb;
|
|
|
|
cout << " " << val - 5/sqrt(float(nb_sucb)) << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TST3() {
|
|
|
|
S.load("sample");
|
|
|
|
A.load("test/tst3.ffa");
|
|
|
|
TransitionFunction T;
|
|
|
|
SFunc Iota, Tau;
|
|
|
|
A.allTransitions(T);
|
|
|
|
A.allStates(Iota);
|
|
|
|
A.allStates(Tau);
|
|
|
|
for (int i=1 ; i<200 ; ++i) {
|
|
|
|
A.BaumWelch(S,T,Iota,Tau,1,true);
|
|
|
|
cout << "." << flush;
|
|
|
|
cout << "\t" << A.Likelihood(S) << "\n";
|
|
|
|
}
|
|
|
|
cout << endl;
|
|
|
|
|
|
|
|
A.erase_bad_states();
|
|
|
|
A.save("test/res.ffa");
|
|
|
|
}
|
|
|
|
|
|
|
|
void TSTprime()
|
|
|
|
{
|
|
|
|
|
|
|
|
string ficech="sample";
|
|
|
|
// cout << "Donnez le fichier contentant l'echantillon : ";
|
|
|
|
// cin >> ficech;
|
|
|
|
S.load(ficech);
|
|
|
|
|
|
|
|
float precision, epsprime;
|
|
|
|
|
|
|
|
cout << "Donnez la precision : ";
|
|
|
|
cin >> precision;
|
|
|
|
cout << "Donnez le seuil de suppression des aretes : ";
|
|
|
|
cin >> epsprime;
|
|
|
|
cout << "Donnez le nombre de tours de BM : ";
|
|
|
|
int nb_tours;
|
|
|
|
cin >> nb_tours;
|
|
|
|
|
|
|
|
A.DEESBM(S,precision,epsprime,true,INT_MAX,0,nb_tours);
|
|
|
|
|
|
|
|
string ficpsA = "test/tmp.ps";
|
|
|
|
string ficdotA= "test/tmp.dot";
|
|
|
|
export_to_pdf(A,ficpsA, ficdotA);
|
|
|
|
show_ps(ficpsA);
|
|
|
|
}
|
|
|
|
|
|
|
|
void proba(void) {
|
|
|
|
string nomfic;
|
|
|
|
Word w;
|
|
|
|
cout << "entrez le fichier : ";
|
|
|
|
cin >> nomfic;
|
|
|
|
A.load(nomfic);
|
|
|
|
cout << "entrez le mot : ";
|
|
|
|
cin >> w;
|
|
|
|
cout << "p(" << w << ")= " << A.p(w) << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Y (void)
|
|
|
|
{
|
|
|
|
int choix;
|
|
|
|
cout << "\t\t1 - BaumWelch sur test/tst3.ffa\n";
|
|
|
|
cout << "\t\t2 - Probabilite d'un mot\n";
|
|
|
|
cout << "\t\t3 - Prefixialise un echantillon\n";
|
|
|
|
cout << "\t\t4 - Choix pour les cysteines\n";
|
|
|
|
cout << "\t\t5 - Apprend ‡ partir d'un Èchantillon avec optimisation du paramËtre\n";
|
|
|
|
cout << "\t\t6 - Apprend ‡ partir d'un Èchantillon\n";
|
|
|
|
cout << "\t\t7 - Cree un PTA ‡ partir d'un Èchantillon\n";
|
|
|
|
cout << "\t\t8 - TST\n";
|
|
|
|
cout << "\n";
|
|
|
|
cout << "choix : ";
|
|
|
|
cin >> choix;
|
|
|
|
|
|
|
|
if (choix == 1) // Une generation aleatoire
|
|
|
|
{
|
|
|
|
TST3();
|
|
|
|
} else if (choix == 2) // Proportion des PRFAs
|
|
|
|
{
|
|
|
|
proba();
|
|
|
|
} else if (choix == 3) // Prefixialise un echantillon
|
|
|
|
{
|
|
|
|
prefixialisa_echantillon();
|
|
|
|
} else if (choix == 4) // Test pondere "intelligent" ?
|
|
|
|
{
|
|
|
|
Choix_cysteines();
|
|
|
|
} else if (choix == 5) //
|
|
|
|
{
|
|
|
|
cout << "Ce choix n'est plus valide !!!" << endl;
|
|
|
|
}
|
|
|
|
else if (choix == 6)
|
|
|
|
{
|
|
|
|
Apprentissage_unique();
|
|
|
|
}
|
|
|
|
else if (choix == 7)
|
|
|
|
{
|
|
|
|
makePTA();
|
|
|
|
}
|
|
|
|
else if (choix == 8)
|
|
|
|
{
|
|
|
|
TST();
|
|
|
|
}
|
|
|
|
else // mauvais choix
|
|
|
|
{
|
|
|
|
cout << "entree inconnue" << endl;
|
|
|
|
}
|
|
|
|
}
|