static void create_snns_unit(void)
{
struct PosType unit_pos;
PLANE *PLANE_element = PLANE_first_element;
int x,y,width,height,unit_no,pos,ret;
int y_offset=0,relative_y_max=0,absolute_y_max=0,y_begin;
int x_max=0,old_x_begin=2,new_x_begin,x_begin;
ret = krui_allocateUnits((*PLANE_last_element).width *
(*PLANE_last_element).height +
(*PLANE_last_element).begin-1);
if(ret != 0){
ui_tw_errorMessage(krui_error(ret));
BN_ERROR = 1;
}
while((! BN_ERROR) && (PLANE_element != NULL)) {
height = (*PLANE_element).height;
width = (*PLANE_element).width;
pos = (*PLANE_element).pos;
y_begin = calculate_y_begin(&absolute_y_max,&relative_y_max,&y_offset,height,pos);
x_begin = calculate_x_begin(&new_x_begin,&old_x_begin,&x_max,width,pos);
for(y=0;y<height;y++){
for(x=0;x<width;x++){
unit_no = krui_createDefaultUnit();
if(unit_no<0) ui_checkError(unit_no);
krui_setUnitActFunc(unit_no, "Act_Perceptron");
ret = krui_setUnitTType(unit_no,(*PLANE_element).type+1);
if(ret != 0){
ui_tw_errorMessage(krui_error(ret));
BN_ERROR = 1;
}
unit_pos.x = x_begin + x;
unit_pos.y = y_begin + y;
krui_setUnitPosition(unit_no,&unit_pos);
}/*for*/
}/*for*/
PLANE_element = (*PLANE_element).next;
}/*while*/
}
krui_err SnnsCLib::bn_kohonen_createNet(int X, int Y, int IUnits, int HUnits)
{
int i,j,unit_no;
struct PosType unit_pos;
krui_err ret;
unit_pos.z = 0;
/* Allocate units */
ret = krui_allocateUnits( HUnits + IUnits );
CHECK_RETURN ( ret );
/* Create standard (input) Units */
unit_pos.x = 1;
for (i = 1; i <= IUnits; i++) {
unit_no = krui_createDefaultUnit();
if (unit_no < 0) CHECK_RETURN( unit_no );
ret = krui_setUnitTType( unit_no, INPUT );
CHECK_RETURN( ret );
unit_pos.y = (IUnits<Y)?i+(Y-IUnits)/2:i;
krui_setUnitPosition( unit_no, &unit_pos );
}
/* Create standard hidden Units. The size of the feature map is X*Y */
for (i = 1; i <= Y; i++)
for (j = 1; j <= X; j++) {
unit_pos.x = 4+j;
unit_no = krui_createDefaultUnit();
if (unit_no < 0) CHECK_RETURN( unit_no );
ret = krui_setUnitTType( unit_no, HIDDEN );
CHECK_RETURN( ret );
unit_pos.y = i;
krui_setUnitPosition( unit_no, &unit_pos );
}
/* Make connections between input units and hidden units */
/* set all link weights to zero */
for (i = IUnits + 1; i <= IUnits + HUnits; i++) {
/* Make hidden unit to current unit */
ret = krui_setCurrentUnit( i );
CHECK_RETURN( ret );
/* (backward) connect current (hidden) unit with input unit */
for (j = 1; j <= IUnits; j++) {
ret = krui_createLink( j,0.0);
CHECK_RETURN( ret );
}
}
/* set the update function */
ret = krui_setUpdateFunc (const_cast<char*>(KOHONEN_UPDATE_FUNC_NAME));
CHECK_RETURN( ret );
/* set the learning function */
ret = krui_setLearnFunc (const_cast<char*>(KOHONEN_LEARN_FUNC_NAME));
CHECK_RETURN( ret );
/* set the init function */
ret = krui_setInitialisationFunc (const_cast<char*>(KOHONEN_INIT_FUNC_NAME));
//CHECK_RETURN( ret );
return(ret);
} /* bn_kohonen_createNet */
/*****************************************************************************
FUNCTION : bn_artmap_make_layer
PURPOSE : make a complete layer
NOTES :
UPDATE : 20.1.1993
******************************************************************************/
krui_err SnnsCLib::bn_artmap_make_layer (int units, int rows, int cols,
int Xbegin, int Ybegin,
char *name_prefix, int unit_ttype,
char *actfuncname, char *outfuncname,
int NoOfSites, char **SiteNames,
char **SiteFuncNames)
{
krui_err ret_code = KRERR_NO_ERROR;
int row;
int col;
int count;
int last_col;
int unit_no;
struct PosType unit_pos;
char *site_name, *site_func_name;
int site_no;
char name[100];
unit_pos.z = 0;
/* Create Site Table Entries */
site_no = 1;
while (site_no <= NoOfSites) {
site_name= *(SiteNames+(site_no-1));
site_func_name= *(SiteFuncNames+(site_no-1));
if ((site_name != NULL) && (site_func_name != NULL)) {
ret_code = krui_createSiteTableEntry(site_name, site_func_name);
CHECK_RETURN (ret_code);
} /*if*/
site_no++;
} /*while*/
/* Create Units */
for (row = 1, count = 0; row <= rows; row++) {
if ((units % rows) > 0) {
last_col = POS_SIGN((units-count) % (rows-row+1));
} else {
last_col = 1;
} /*if*/
for (col = 1; col <= (cols-1+last_col); col++) {
count++;
unit_no = krui_createDefaultUnit();
if (unit_no < 0) CHECK_RETURN (unit_no);
ret_code = krui_setUnitTType (unit_no, unit_ttype);
CHECK_RETURN( ret_code );
ret_code = krui_setUnitActFunc(unit_no, actfuncname);
CHECK_RETURN (ret_code);
ret_code = krui_setUnitOutFunc(unit_no, outfuncname);
CHECK_RETURN (ret_code);
if (units > 1) {
sprintf (name,"%s%d",name_prefix,count);
} else {
sprintf (name,"%s",name_prefix);
} /*if*/
ret_code = krui_setUnitName (unit_no, name);
CHECK_RETURN (ret_code);
unit_pos.x = Xbegin + col - 1;
unit_pos.y = Ybegin + row - 1;
krui_setUnitPosition( unit_no, &unit_pos );
ret_code = krui_setCurrentUnit (unit_no);
CHECK_RETURN (ret_code);
/* Add Sites */
site_no = 1;
while (site_no <= NoOfSites) {
site_name= *(SiteNames+(site_no-1));
if (site_name != NULL) {
ret_code = krui_addSite (site_name);
CHECK_RETURN (ret_code);
} /*if*/
site_no++;
} /*while*/
} /*for*/
} /*for*/
return (ret_code);
}
krui_err SnnsCLib::bn_assoz_createNet(int X, int Y)
{
int i,j,unit_no;
struct PosType unit_pos;
krui_err ret = KRERR_NO_ERROR;
int HUnits= X*Y;
int IUnits= X*Y;
/* Allocate units */
ret = krui_allocateUnits( IUnits + HUnits );
CHECK_RETURN (ret);
/* Create standard input Units. The size of the input layer is X*Y */
for (i = 1; i <= Y; i++)
for (j = 1; j <= X; j++) {
unit_pos.x = j;
unit_no = krui_createDefaultUnit();
if (unit_no < 0) CHECK_RETURN (unit_no);
ret = krui_setUnitTType( unit_no, INPUT );
CHECK_RETURN (ret);
ret = krui_setUnitActFunc( unit_no, const_cast<char*>("Act_RM") );
CHECK_RETURN (ret);
unit_pos.y = i;
krui_setUnitPosition( unit_no, &unit_pos );
}
/* Create standard hidden Units. The size of the output layer is X*Y */
for (i = 1; i <= Y; i++)
for (j = 1; j <= X; j++) {
unit_pos.x = X+4+j;
unit_no = krui_createDefaultUnit();
if (unit_no < 0) CHECK_RETURN (unit_no);
ret = krui_setUnitTType( unit_no, HIDDEN );
CHECK_RETURN (ret);
ret = krui_setUnitActFunc( unit_no, const_cast<char*>("Act_RM") );
CHECK_RETURN (ret);
unit_pos.y = i;
krui_setUnitPosition( unit_no, &unit_pos );
}
/* Make connections between input units and hidden units */
for (i = IUnits + 1; i <= IUnits + HUnits; i++) {
/* Make hidden unit to current unit */
ret = krui_setCurrentUnit( i );
CHECK_RETURN (ret);
/* (backward) connect current (hidden) unit with input unit */
/* set all link weights from the input units to one */
ret = krui_createLink( i-IUnits, 1.0);
CHECK_RETURN (ret);
/* Make connections from all hidden units */
/* set link weights to zero */
for (j = IUnits + 1; j <= IUnits + HUnits; j++) {
if (j != i){
ret = krui_createLink( j, 0.0);
CHECK_RETURN (ret);
}
}
}
/* set the update function */
ret = krui_setUpdateFunc (const_cast<char*>(ASSOZ_UPDATE_FUNC_NAME));
CHECK_RETURN (ret);
/* set the learning function */
ret = krui_setLearnFunc (const_cast<char*>(ASSOZ_LEARN_FUNC_NAME));
CHECK_RETURN (ret);
/* set the init function */
ret = krui_setInitialisationFunc (const_cast<char*>(ASSOZ_INIT_FUNC_NAME));
//CHECK_RETURN (ret);
return(ret);
} /* bn_assoz_createNet */
static inline void creatUnit(IPackage&p,IConnection*c)
{
uint32 subnet;
uint16 numunits;
SUnit unit,ounit;
p>>subnet>>numunits;
IPackage op("set");
op<<QString("create unit");
op<<subnet<<numunits;
int num,err;
//yet no check for subnet/layer defined, SNNS itself gives damn
//buffer for string ops:
char buf[256];
//create units
for(int i=0;i<numunits;i++){
getUnit(unit,p);
ounit=unit;
num=krui_createDefaultUnit();
if(num<0){//error
ounit.mask=UERR;
ounit.errcode=(QString)krui_error(-num);
setUnit(ounit,op);
//proceed with next unit
continue;
}else{//success
ounit.mask|=UNUM;
ounit.id=num;
}
//subnet/layer
krui_setUnitLayerNo(num,subnet&0xffff);
int subn=(subnet>>16)&0xffff;
subn-=32736;
krui_setUnitSubnetNo(num,subn);
//name
if(unit.mask&UNAME){
err=krui_setUnitName(num,CHR(buf,unit.name));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}
//output function
if(unit.mask&UOUTF){
err=krui_setUnitOutFunc(num,CHR(buf,unit.outfunc));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}//must be for error and nomask, doesn't hurt anyway
ounit.mask|=UOUTF;
ounit.outfunc=krui_getUnitOutFuncName(num);
//activation function
if(unit.mask&UACTF){
err=krui_setUnitActFunc(num,CHR(buf,unit.actfunc));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}
ounit.mask|=UACTF;
ounit.actfunc=krui_getUnitActFuncName(num);
//initial activation
if(unit.mask&UIACT)
krui_setUnitInitialActivation(num,unit.iact);
//activation
if(unit.mask&UACT)
krui_setUnitActivation(num,unit.act);
//bias
if(unit.mask&UBIAS)
krui_setUnitBias(num,unit.bias);
//prototype
if(unit.mask&UPROTO){
err=krui_setUnitFType(num,CHR(buf,unit.prototype));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
ounit.prototype=(char*)0;
//take this as non-fatal and proceed
}
}
//position
if(unit.mask&UPOS){
struct PosType pos;
pos.x=unit.xpos;
pos.y=unit.ypos;
pos.z=unit.zpos;
krui_setUnitPosition(num,&pos);
//the above doesn't transport errors, so ...
krui_getUnitPosition(num,&pos);
ounit.xpos=pos.x;
ounit.ypos=pos.y;
ounit.zpos=pos.z;
}else {
struct PosType pos;
ounit.mask|=UPOS;
krui_getUnitPosition(num,&pos);
ounit.xpos=pos.x;
ounit.ypos=pos.y;
ounit.zpos=pos.z;
}
//send back
setUnit(ounit,op);
}
c->send(op);
}
static inline void modifUnit(IPackage&p,IConnection*c)
{
uint32 subnet;
uint16 numunits;
int err;
SUnit unit,ounit;
IPackage op("set");
op<<QString("modify unit");
op<<subnet<<numunits;
char buf[256];
for(int i=0;i<numunits;i++){
getUnit(unit,p);
ounit=unit;
//check for existance
if(!(unit.mask&UNUM)){
int num=krui_createDefaultUnit();
if(num<0){
ounit.errcode="Unable to create unit.";
setUnit(ounit,op);
continue;
}
unit.id=ounit.id=num;
}
if(unit.id==0||unit.id>krui_getNoOfUnits()){
ounit.mask=UERR|UNUM;
ounit.errcode="Unit doesn't exist.";
setUnit(ounit,op);
continue;
}
//prototype
if(unit.mask&UPROTO){
err=krui_setUnitFType(unit.id,CHR(buf,unit.prototype));
if(err){
ounit.prototype=krui_getUnitFTypeName(unit.id);
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}
//position
if(unit.mask&UPOS){
PosType pos;
pos.x=unit.xpos;
pos.y=unit.ypos;
pos.z=unit.zpos;
krui_setUnitPosition(unit.id,&pos);
krui_getUnitPosition(unit.id,&pos);
ounit.xpos=pos.x;
ounit.ypos=pos.y;
ounit.zpos=pos.z;
}
//bias
if(unit.mask&UBIAS){
krui_setUnitBias(unit.id,unit.bias);
}
//i_activation
if(unit.mask&UIACT){
krui_setUnitInitialActivation(unit.id,unit.iact);
}
//activation
if(unit.mask&UACT){
err=krui_setUnitActivation(unit.id,unit.act);
if(err){
ounit.act=krui_getUnitActivation(unit.id);
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
}
}
//actfunc
if(unit.mask&UACTF){
err=krui_setUnitActFunc(unit.id,CHR(buf,unit.actfunc));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
ounit.actfunc=krui_getUnitActFuncName(unit.id);
}
}
//outfunc
if(unit.mask&UOUTF){
err=krui_setUnitOutFunc(unit.id,CHR(buf,unit.outfunc));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
ounit.outfunc=krui_getUnitOutFuncName(unit.id);
}
}
//name
if(unit.mask&UNAME){
err=krui_setUnitName(unit.id,CHR(buf,unit.name));
if(err){
ounit.mask|=UERR;
ounit.errcode=krui_error(err);
ounit.name=krui_getUnitName(unit.id);
}
}
//store
setUnit(ounit,op);
}
c->send(op);
}
void create_network(char *weight_file)
{
FILE *fp;
float val;
/* Allocate units (the user may or may not use this function,
there is no need to do this) */
ret = krui_allocateUnits( OUnits + HUnits + IUnits );
errChk( ret );
printf( "\n\nCreate Units now\n" );
/* Create standard (input) Units */
unit_pos.x = 1;
for (i = 1; i <= IUnits; i++)
{
unit_no = krui_createDefaultUnit();
if (unit_no < 0) errChk( unit_no );
ret = krui_setUnitTType( unit_no, INPUT );
errChk( ret );
unit_pos.y = (IUnits<Y)?i+(Y-IUnits)/2:i;
krui_setUnitPosition( unit_no, &unit_pos );
}
/* Create standard (hidden) Units */
for (i = 1; i <= Y; i++)
for (j = 1; j <= X; j++)
{
unit_pos.x = 4+j;
unit_no = krui_createDefaultUnit();
if (unit_no < 0) errChk( unit_no );
ret = krui_setUnitTType( unit_no, HIDDEN );
errChk( ret );
unit_pos.y = i;
krui_setUnitPosition( unit_no, &unit_pos );
}
/* Create standard (output) Units */
unit_pos.x = 4+X+3;
if (OUnits) for (i = 1; i <= OUnits; i++)
{
unit_no = krui_createDefaultUnit();
if (unit_no < 0) errChk( unit_no );
ret = krui_setUnitTType( unit_no, OUTPUT );
errChk( ret );
unit_pos.y = (OUnits<Y)?i+(Y-OUnits)/2:i;
krui_setUnitPosition( unit_no, &unit_pos );
}
/* Make Connections now */
/* Make connections between hidden units and output units first ! */
for (i = IUnits + HUnits + 1; i <= IUnits + HUnits + OUnits; i++)
{ /* Make output unit to current unit */
ret = krui_setCurrentUnit( i );
errChk( ret );
for (j = IUnits + 1; j <= IUnits + HUnits; j++)
{ /* connect current (output) unit with hidden unit.
REMEMBER: The hidden unit #j is the predecessor of
the (output) unit #i (it is a backward connection) */
ret = krui_createLink( j, 0 );
errChk( ret );
}
}
/* Make connections between input units and hidden units
and set link weight with datas from output_file */
printf("\nSet link weights now\n");
if((fp=fopen(weight_file,"r"))!=NULL)
for (i = IUnits + 1; i <= IUnits + HUnits; i++)
{ /* Make hidden unit to current unit */
ret = krui_setCurrentUnit( i );
errChk( ret );
for (j = 1; j <= IUnits; j++)
{ /* (backward) connect current (hidden) unit with input unit */
fscanf(fp,"%s",string);
val = atof(string);
ret = krui_createLink( j,val);
errChk( ret );
}
}
else{ /* set all link weights to zero */
for (i = IUnits + 1; i <= IUnits + HUnits; i++)
{ /* Make hidden unit to current unit */
ret = krui_setCurrentUnit( i );
errChk( ret );
for (j = 1; j <= IUnits; j++)
{/* (backward) connect current (hidden) unit with input unit */
ret = krui_createLink( j,0);
errChk( ret );
}
}
printf("\nWeight file %s could not be opened!\n",weight_file);
printf("All weights have been set to zero!\n");
}
fclose(fp);
/* set the update function */
ret = krui_setUpdateFunc (KOHONEN_UPDATE_FUNC_NAME);
errChk( ret );
/* set the learning function */
ret = krui_setLearnFunc (KOHONEN_LEARN_FUNC_NAME);
errChk( ret );
/* set the init function */
ret = krui_setInitialisationFunc (KOHONEN_INIT_FUNC_NAME);
errChk( ret );
printf("\nEnter Filename of the Network to save: ");
scanf("%s", name);
strcat(name,".net");
printf("Save Network\n");
/* save the network */
ret = krui_saveNet( name, NULL );
errChk( ret );
printf( "\nCreate Patterns now\n" );
} /* end of create_network */
