/*
Running NeuroCode model "model0"
Ce code a été crée automatiquement par le module NEURO CODE à partir d'un
modèle neuronal développé avec un outil de la
Suite NEURO ONE
Le présent code source généré par le progiciel NEURO CODE est protégé tant
par les dispositions nationales qu'internationales en matière de droits de
la propriété intellectuelle, dont les droits sont détenus, à titre
exclusif, par la société NETRAL.
L'utilisation et la modification de ce code source est soumise à un contrat
de licence d'utilisation.
La contrefaçon est un délit pénal puni de 2 ans d'emprisonnement et de
150.000 Euros d'amende.
Le modèle du présent code source a fait l'objet d'un dépôt auprès de
l'Agence pour la Protection des Programmes sous le numéro :
IDDN.FR.001.500018.00.S.P.1999.000.20700
NETRAL ne peut en aucun cas être tenu pour responsable des conséquences de
l'utilisation de ce code.
Lisez attentivement le fichier "licfr.txt" joint à ce fichier pour
connaitre vos droits et obligations concernant l'usage de ce code.
Pour obtenir une licence ou tout renseignement complémentaire,
adressez vous à :
NETRAL
14, rue Verdi
9213 Issy-les-Moulineaux
tel : (33) 146 387 512
email: info@netral.com
Date : 25/10/2005
Time : 17:29:20
User : Jean_Luc_PLOIX
Computer : SOPHRONE
Counter : 2
NetworkName : model0
FileName : D:\Program Files\Netral\Data\Exemples\Modeles\Static.NML
*/
/*
# Cette partie du fichier peut être copié dans un éditeur de texte, et sauvegardé
# comme fichier "Makefile" dans le répertoire de ce fichier.
# En fonction de la configuration de votre machine, quelques modifications doivent
# être faites à ce fichier Makefile
# Par exemple, vous pouvez changer :
# le compilateur C
# la localisation des fichiers communs
# Une fois ces modifia=cations apportées, appelez l'utilitaire Make pour compiler
# le programme model0use
#
# Les informations sur le programme model0use sont fournies dans le fichier Use.txt.
# The following part of the file can be copied into a text editor, and saved
# as "Makefile" file in the folder of this file.
# Depending upon the configuration of your machine, some modification must be
# done on this Makefile.
# For instance, you may change :
# the C compiler
# the common files location
# Once the modification are done, call the make utity in order to compile the
# model0train program
#
# Information on model0train program are provided in the train.txt file
#------------------ Suggested Makefile ----------------------------------------
# Make for model0train project
CC=gcc
NETRALTYPREAD = netraltype.h readfile.c netraltype.h readfile.c
NETRALTYP = netraltype.h netraltype.c
OBJS = mathplus.o \
netraltyê.o \
readfile.o \
model0tfr.o \
model0grd.o \
model0lev.o \
model0trn.o \
model0maintrain.o
model0train : $(OBJS)
$(CC) $(OBJS) -o model0train
readfile.o: $(NETRALTYPREAD)
$(CC) -c readfile.c
mathplus.o: mathplus.h mathplus.c
$(CC) -c mathplus.c
netraltype.o: $(NETRALTYP)
$(CC) -c netraltype.c
model0tfr.o : model0tfr.h $(NETRALTYPREAD)
$(CC) -c model0tfr.c
model0grd.o : model0grd.h $(NETRALTYPREAD) model0tfr.h
$(CC) -c model0grd.c
model0lev.o : model0lev.h $(NETRALTYPREAD) model0tfr.h model0grd.h
$(CC) -c model0lev.c
model0trn.o : model0trn.h $(NETRALYTYP) model0tfr.h model0grd.h model0lev.h
$(CC) -c model0trn.c
model0maintrain.o : model0maintrain.h $(NETRALTYPREAD) model0tfr.h model0lev.h model0trn.h
$(CC) -c model0maintrain.c
#------------------------------------------------------------------------------*/
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
/* Please check name and path of included files */
/* Veuillez vérifier le nom et le chemin des fichiers inclus */
#include "readfile.h" /* reading description and data files.*/
#include "netraltype.h" /* defining real type*/
#include "model0tfr.h"
#include "model0lev.h"
#include "model0trn.h"
#define DESC "ndesc.txt" /* default description file.*/
#define WEIGHTS "weights" /* tag for weights files.*/
#define RES "res" /* tag for training result files.*/
#define HISTORY "history" /* tag for training history files.*/
#define USEHIST "usehist" /* tag for usage history files.*/
#define RESU "use" /* tag for usage result files.*/
/* Global variables */
/* Variables globales */
real *datatarget;
real *costlist;
real *gencostlist;
long *tablend;
long *lineperfile;
tdatastruct datastruct;
long model0INOUT=model0INPUTS + model0OUTPUTS;
long model0IN2OUT=model0INPUTS + 2*model0OUTPUTS;
long initsource(long val, char* desc)
/* Initialization of tables and model affectation */
/* Initialisation des tables et affectation des paramètres du modèle */
{
if (val)/* training case */
{
long i, res;
long cumul=0;
initdata(desc, &datastruct);
srand(datastruct.seed);
if (datastruct.leverage)
{
gencostlist = (real*)calloc(datastruct.ntrain*(datastruct.nepoch+1), sizeof(real));
if (!gencostlist) return 3;
}
costlist = (real*)calloc(datastruct.ntrain*(datastruct.nepoch+1), sizeof(real));
if (!costlist) return 2;
tablend = (long*)calloc(datastruct.ntrain, sizeof(long));
if (!tablend) return 2;
if ((datastruct.nout - model0OUTPUTS)||(datastruct.ndatatarget - model0IN2OUT))
{
printf(ST_SIZEERRPOR, datastruct.ndatatarget, model0INOUT);
getchar();
return 2;
}
datatarget = (real*)calloc((datastruct.ndatatarget + model0OUTPUTS) * datastruct.linetoread, sizeof(real));
if (!datatarget) return 2;
res = model0init(datastruct.linetoread, 0, datatarget, NULL);
if (res) return 1;
lineperfile = (long*)calloc(datastruct.nfile, sizeof(long));
if (!lineperfile) return 1;
printf(ST_DATALOADING, MODEL);
for (i=0; i < datastruct.nfile; i++)
{
lineperfile[i] = readdata(&datastruct, i, datatarget, cumul);
cumul += lineperfile[i];
printf(ST_DATALOADED, i, datastruct.datafilename[i], cumul);
}
}
else /* usage case *//* Cas de l'utilisation */
{
initdata(desc, &datastruct);
}
return 0;
}
void freesource(long val)
/* Free all tables */
/* Libération de toutes les tables */
{
if (val)
{
model0free();
free(lineperfile);
free(tablend);
free(costlist);
free(datatarget);
if (datastruct.leverage)
{
free(gencostlist);
}
}
freedata(&datastruct);
}
char* datatablefile(char *dest)
/* Result table file name */
/* Nom de la table des résultats */
{
return strcat(strcpy(dest, datastruct.resultpath), "internaldata.csv");
}
char *historyfile(char *dest, long index)
/* Training history file name */
/* Nom du fichier historique d'apprentissage */
{
sprintf(dest, "%s%s%s%d%s", datastruct.resultpath, MODEL, HISTORY, index, ".txt");
return dest;
}
char *usehistoryfile(char *dest)
/* Usage history file name */
/* Nom du fichier historique d'utilisation */
{
sprintf(dest, "%s%s%s%s", datastruct.resultpath, MODEL, USEHIST, ".txt");
return dest;
}
char *curfile(char *dest, long index)
/* training result current file name */
/* Nom du fichier de résultat courant */
{
sprintf(dest, "%s%s%s%d%s", datastruct.resultpath, MODEL, RES, index, ".txt");
return dest;
}
char *bestfile(char *dest)
/* Best training result file name */
/* Nom du fichier de meilleur résultat */
{
sprintf(dest, "%s%s%s%s", datastruct.resultpath, MODEL, WEIGHTS, ".txt");
return dest;
}
char *curusefile(char *dest, long index)
/* Usage result file name */
/* Nom du fichier courant d'utilisation */
{
sprintf(dest, "%s%s%s%d%s", datastruct.resultpath, MODEL, RESU, index, ".csv");
return dest;
}
char* headercurbuf(char* buffer, long index, enum ttrainend trainend, real stdcost, real stdgen)
/* Usage file header */
/* En tete du fichier d'usage courant */
{
long i, j, ii;
char bufloc[1024];
sprintf(buffer, ST_STRAINING, MODEL, index + 1, datastruct.ntrain);
if (trainend != teEpoch)
{
sprintf(bufloc, ST_ENDTRAINING, trainend);
strcat(buffer, bufloc);
strcat(buffer, "\n");
}
strcat(buffer, ST_DATAFIELDS);
for (i=0; i < datastruct.nindata; i++)
{
for (j=0; j < datastruct.ldepth[i]; j++)
{
if (i + j)
strcat(buffer, datastruct.separator);
sprintf(bufloc, "%s", datastruct.titles[datastruct.colio[i]]);
strcat(buffer, bufloc);
ii = datastruct.udepth[i*datastruct.ndepth + j];
if (ii)
{
sprintf(bufloc, "[%ld]", ii);
strcat(buffer, bufloc);
}
}
}
for (i=0; i < datastruct.nfile; i++)
{
strcat(buffer, "\n");
sprintf(bufloc, ST_DATALOADEDL, i, datastruct.datafilename[i], lineperfile[i]);
strcat(buffer, bufloc);
}
strcat(buffer, "\n");
sprintf(bufloc, ST_TOTALLINE, datastruct.linetoread);
strcat(buffer, bufloc);
strcat(buffer, "\n");
sprintf(bufloc, ST_ERRORSTD, stdcost);
strcat(buffer, bufloc);
if (stdgen)
{
sprintf(bufloc, ST_ERRORGENSTD, stdgen);
strcat(buffer, bufloc);
}
return buffer;
}
long singletrain(long index, real *cost)
/* Single initialization training */
/* Un seul apprentisage */
{
FILE *file;
char headerbuffer[4096];
enum ttrainend trainend;
long nb=1;
long i;
long code = 0;
long test=0;
char buffer[1024];
real stdcost;
real stdgen = 0;
time_t starttime;
starttime = time(NULL);
*cost = model0getcost(&test);
stdcost = sqrt(*cost);
costlist[index*(datastruct.nepoch+1)] = stdcost;
if (datastruct.leverage)
gencostlist[index*(datastruct.nepoch+1)] = 0;
for (i=0; i < datastruct.nepoch; i++)
{
/* training launch */
/* lancement de l'apprentisage */
test = model0train(&nb, (long*)&trainend, cost);
if (datastruct.leverage)
{
stdgen = sqrt(model0setleverages(&code)/DataCount);
gencostlist[index*datastruct.ntrain + i] = stdgen;
}
stdcost = sqrt(*cost);
costlist[index*datastruct.ntrain + i] = stdcost;
/* display result */
/* Afficher les résultats */
if (datastruct.leverage)
printf(ST_COSTL, index+1, i + 1, datastruct.nepoch, stdcost, stdgen, time(NULL)-starttime);
else
printf(ST_COSTS, index+1, i + 1, datastruct.nepoch, stdcost, time(NULL)-starttime);
/* writing current weights */
/* écrire les poids courants */
curfile(buffer, index);
headercurbuf(headerbuffer, index, trainend, stdcost, stdgen);
if (datastruct.leverage)
model0savewl(buffer, headerbuffer);
else
model0savew(buffer, headerbuffer);
/* writing cost history */
/* écrire l'histoire des coûts */
historyfile(buffer, index);
file = fopen(buffer, "a");
if (file)
{
if (datastruct.leverage)
fprintf(file, "%20.16E%s%20.16E\n", stdcost, datastruct.separator, stdgen);
else
fprintf(file, "%20.16E\n", stdcost);
fclose(file);
}
if ((test) || (nb < 1)) break;
}
tablend[index] = (long)trainend;
return trainend;
}
long trainall(void)
/* All the training */
/* Tous les apprentissages */
{
FILE *file;
long index;
real cost;
real bestcost = 1E60;
char buffer[1024];
char bufloc[1024];
for (index=0; index < datastruct.ntrain; index++)
{
model0iniweights(datastruct.wsd);
printf(ST_TRAINING, index + 1, datastruct.ntrain);
/* preparing history file */
/* préparer le fichier historique */
historyfile(buffer, index);
file = fopen(buffer, "w");
if (file)
{
fprintf(file, ST_TRAINHIST, MODEL, index + 1, datastruct.ntrain);
fclose(file);
}
singletrain(index, &cost);
/* writing best training weights */
/* écrire les meilleurs poids */
if (cost < bestcost)
{
bestcost = cost;
bestfile(buffer);
sprintf(bufloc, ST_STRAINING, MODEL, index+1, datastruct.ntrain);
if (datastruct.leverage)
model0savewl(buffer, bufloc);
else
model0savew(buffer, bufloc);
}
}
return 0;
}
long singleuse(long index)
/* Single file usage */
/* Utilisation avec un seul fichier */
{
FILE *sourcefile;
FILE *targetfile;
FILE *historyfile;
char buffer[1024];
char* sourcename;
char* token;
long curline, curval;
long i, j, ii;
real* target;
real rbuf[255];
real cost = 0;
real curdelta;
extern long verb;
sourcename = datastruct.datafilename[index];
targetfile = fopen(curusefile(buffer, index), "w");
if (targetfile)
{
fprintf(targetfile, ST_USAGEWITH, MODEL, sourcename);
for (i=0; i < datastruct.nindata; i++)
{
for (j=0; j < datastruct.ldepth[i]; j++)
{
if (i + j)
fprintf(targetfile, "%s", datastruct.separator);
fprintf(targetfile, "%s", datastruct.titles[datastruct.colio[i]]);
ii = datastruct.udepth[i*datastruct.ndepth + j];
if (ii)
fprintf(targetfile, "[%ld]", ii);
}
}
for (i=0; i < model0OUTPUTS; i++)
fprintf(targetfile, ST_COMPUTED_, datastruct.separator, datastruct.titles[datastruct.colio[i + datastruct.nindata - model0OUTPUTS]]);
if (datastruct.leverage)
for (i=0; i < model0OUTPUTS; i++)
fprintf(targetfile, ST_LEVERAGE_, datastruct.separator, datastruct.titles[datastruct.colio[i + datastruct.nindata - model0OUTPUTS]]);
fprintf(targetfile, "\n");
sourcefile = fopen(sourcename, "r");
if (sourcefile)
{
curline = - datastruct.delaymini;
while ((!feof(sourcefile)) && (curline < datastruct.linetoread))
{
token = fgets(buffer, BUFFERSIZE-1, sourcefile);
curval = translateline(token, &datastruct);
if (verb && (curval != datastruct.ndataperline))
{
printf(ST_ERRORFD, sourcename,\
curline + datastruct.delaymini + 1, curval, datastruct.ndataperline);
}
if (curline >= 0)
{
for (i = 0; i < 255; rbuf[i++] = 0);
target = getline(rbuf, &datastruct);
if (datastruct.leverage)
model0transferlev(target, &rbuf[model0INOUT], &rbuf[model0IN2OUT]);
else
model0transfer(target, &rbuf[model0INOUT]);
curdelta = rbuf[model0INPUTS] - rbuf[model0INOUT];
cost += (curdelta)*(curdelta);
for (i=0; i < datastruct.ndatatarget; i++)
{
if (i)
fprintf(targetfile, "%s", datastruct.separator);
fprintf(targetfile, "%g", target[i]);
}
for (i=0; i < model0OUTPUTS; i++)
{
fprintf(targetfile, "%s%g", datastruct.separator, target[model0INOUT + i]);
if (verb)
printf("%s%g", datastruct.separator, target[model0INOUT + i]);
}
if (datastruct.leverage)
for (i=0; i < model0OUTPUTS; i++)
{
fprintf(targetfile, "%s%g", datastruct.separator, target[model0IN2OUT + i]);
if (verb)
printf("%s%g", datastruct.separator, target[model0IN2OUT + i]);
}
fprintf(targetfile, "\n");
if (verb)
printf("\n");
}
(curline)++;
}
fclose(sourcefile);
cost = sqrt(cost/curline);
printf(ST_DATASTD, sourcename);
printf("%10.4g\n", cost);
historyfile = fopen(usehistoryfile(buffer), "a");
if (historyfile)
{
fprintf(historyfile, ST_DATASTD, sourcename);
fprintf(historyfile, "%20.16f\n", cost);
fclose(historyfile);
}
}
else
{
fprintf(targetfile, ST_SOURCENO, sourcename);
printf(ST_SOURCENO, sourcename);
}
fclose(targetfile);
}
else
printf(ST_TARGETNO, buffer);
return 0;
}
long useall(void)
/* All files usage */
/* Utilisation avec tous les fichiers */
{
long i;
FILE* historyfile;
char buffer[1024];
if (!model0loadw(datastruct.weightfilename))
{
historyfile = fopen(usehistoryfile(buffer), "w");
if (historyfile)
{
fprintf(historyfile, ST_USEHIST);
fclose(historyfile);
}
for (i=0; i < datastruct.nfile; i++)
{
singleuse(i);
}
}
return 0;
}
long analysecommandline(int argc, char* argv[], long* valtrain, char* desc)
/* Command line analysis */
/* Analyse de la ligne de commande */
{
long i;
*valtrain = 1;
extern long verb;
for (i=0; i < argc; i++)
if ((argv[i][0] == '/')||(argv[i][0] == '-'))
{
*valtrain = *valtrain && (!((strlen(argv[i]) == 2) && ((argv[i][1] == 'u') || (argv[i][1] == 'U'))));
if ((strlen(argv[i]) > 2) && ((argv[i][1] == 'd') ||(argv[i][1] == 'D')))
strcpy(desc, &argv[i][2]);
if ((strlen(argv[i]) == 2) && ((argv[i][1] == 'v') || (argv[i][1] == 'V')))
verb = 1;
}
return 0;
}
int model0trainmain(int argc, char* argv[])
/* Main program */
/* Programme principal */
{
FILE* file;
long i, j, k, ii;
char buffer[1024];
char bufferdesc[1024];
long valtrain = 1;
extern long verb;
strcpy(bufferdesc, DESC);
analysecommandline(argc, argv, &valtrain, bufferdesc);
if (!initsource(valtrain, bufferdesc))
{
if (valtrain)
{
if (verb)
{
printf(ST_FIRDSTDATA);
for (i=0; i < datastruct.nindata; i++)
{
k = 0;
for (j=0; j < datastruct.ldepth[i]; j++)
{
printf("%s", datastruct.titles[datastruct.colio[i]]);
ii = datastruct.udepth[i*datastruct.ndepth + j];
if (ii)
printf("[%ld]", ii);
printf("\t%g\n", datatarget[k++]);
}
}
file = fopen(datatablefile(buffer), "w");
if (file)
{
for (i=0; i < datastruct.nindata; i++)
{
for (j=0; j < datastruct.ldepth[i]; j++)
{
if (i + j)
fprintf(file, "%s", datastruct.separator);
fprintf(file, "%s", datastruct.titles[datastruct.colio[i]]);
ii = datastruct.udepth[i*datastruct.ndepth + j];
if (ii) fprintf(file, "[%ld]", ii);
}
}
for (i=0; i < model0OUTPUTS; i++)
{
fprintf(file, ST_COMPUTED_, datastruct.separator, datastruct.titles[datastruct.colio[datastruct.nindata-model0OUTPUTS+i]]);
fprintf(file, "\n");
}
for (i=0; (i < datastruct.linetoread)&&(i < 5); i++)
{
for (j=0; j < model0IN2OUT; j++)
{
if (j) fprintf(file, "%s", datastruct.separator);
fprintf(file, "%g", datatarget[i*model0IN2OUT + j]);
}
fprintf(file, "\n");
}
fclose(file);
}
}
trainall();
}
else
useall();
}
if (verb||(!valtrain))
{
printf(ST_PRESSANYK);
getchar();
}
freesource(valtrain);
return 0;
}
int main(int argc, char* argv[])
{
return model0trainmain(argc, argv);
}
NETRAL - Neuro Code 6