int main()
{
while (true)
{
scanf("%d%d",&n,&m);
if (n == 0 && m == 0) break;
g.Reset(n+2,0,n+1);
g.InsertEdge(0,1,n*2);
for (int i = 1;i <= n;i++)
{
int cnt,v;
scanf("%d",&cnt);
for (int j = 1;j <= cnt;j++)
{
scanf("%d",&v);
g.InsertEdge(i,v,1);
}
g.InsertEdge(i,n+1,2);
}
cout << g.Dinic() << endl;
}
}
void NetworkTests::NetworkTestTrieschAndFoldiak(int mpiRank, int mpiSize)
{
DataSources dataSources;
int sizeX = 5;//10;
int sizeY = 5;//10;
int nrItems = 2500;
bool isTriesch = true;
Network* network = new Network();
network->SetMPIParameters(mpiRank,mpiSize);
int nrInputHypercolumns = 1;
int nrInputRateUnits = sizeX*sizeY;
int nrOutputHypercolumns = 2;
int nrOutputRateUnits = 5;//sizeX+sizeY;
PopulationColumns* layer1 = new PopulationColumns(network,nrInputHypercolumns,nrInputRateUnits,PopulationColumns::GradedThresholded);
PopulationColumns* layer2 = new PopulationColumns(network,nrOutputHypercolumns,nrOutputRateUnits,PopulationColumns::GradedThresholded);
network->AddPopulation(layer1);
network->AddPopulation(layer2);
FullConnectivity* full = new FullConnectivity();
FullConnectivity* full2;
FullConnectivityNoLocalHypercolumns* full3NoLocal;
layer2->AddPre(layer1,full);
bool thresholded = true;
ProjectionModifierTriesch* eTriesch = new ProjectionModifierTriesch(0.002f,0.2f,0.05f,1.0f/float(nrOutputRateUnits), thresholded);//0.05,0.2,0.005,1.0/(float)nrOutputRateUnits, thresholded);
if(isTriesch)
full->AddProjectionsEvent(eTriesch);
//float eta1 = 3, eta2= 2.4, eta3 = 1.5, alpha = 0.005, beta = 200;
float eta1 = 0.5, eta2= 0.02, eta3 = 0.02, alpha = 0.0005, beta = 10;//alpha = 1.0/8.0, beta = 10;
bool lateral = false;
ProjectionModifierFoldiak* eFoldiak = new ProjectionModifierFoldiak(eta1, eta2, eta3, alpha, beta, lateral);
lateral = true;
alpha = 0.75;
ProjectionModifierFoldiak* eFoldiakLateral = new ProjectionModifierFoldiak(eta1, eta2, eta3, alpha, beta, lateral);
//ProjectionModifierBCM* eBCM = new ProjectionModifierBCM(0.1,0.05,20);
if(!isTriesch)
{
full2 = new FullConnectivity();
layer2->AddPre(layer2,full2);
full->AddProjectionsEvent(eFoldiak);
full2->AddProjectionsEvent(eFoldiakLateral);
}
else
{
full3NoLocal = new FullConnectivityNoLocalHypercolumns();
//full3NoLocal->AddProjectionsEvent(eBCM);
full3NoLocal->AddProjectionsEvent(eFoldiakLateral);
layer2->AddPre(layer2,full3NoLocal);
}
// implements N here
SoftMax* softmax = new SoftMax(SoftMax::WTAThresholded,0.5);//(10.0, SoftMax::ProbWTA);
WTA* wta = new WTA();
//layer2->AddPopulationModifier(wta);
layer2->AddPopulationModifier(softmax);
network->Initialize();
//////////////////////////////
// Meters
char* name1 = new char[50];
char* name2 = new char[50];
sprintf(name1,"Projection_triesch_n%d.csv",mpiRank);
Meter* connMeter = new Meter(name1, Storage::CSV);
connMeter->AttachProjection(layer2->GetIncomingProjections()[0],0);
network->AddMeter(connMeter);
sprintf(name2,"Layer2Activity_triesch.csv");
Meter* layerMeter = new Meter(name2, Storage::CSV);
layerMeter->AttachPopulation(layer2);
network->AddMeter(layerMeter);
// end Meters
//////////////////////////////
vector<vector<float> > trainData = dataSources.GetBars(sizeX,sizeY, nrItems);
int iterations = 1;
int iterSameStimuli = 100;
if(!isTriesch)
iterSameStimuli = 10;
layer1->SwitchOnOff(false); // fixed during training phase
for(int j=0;j<iterations;j++)
{
for(int i=0;i<trainData.size();i++)
{
/*if(!isTriesch)
{
// in order to settle recurrent activity
eFoldiak->SwitchOnOff(false);
eFoldiakLateral->SwitchOnOff(false);
}*/
for(int k=0;k<iterSameStimuli;k++)
{
/* if(!isTriesch && k==iterSameStimuli-1)
{
eFoldiak->SwitchOnOff(true);
eFoldiakLateral->SwitchOnOff(true);
}
*/
for(int m=0;m<1;m++)
{
layer1->SetValuesAll(trainData[i]);
//for(int n=0;n<3;n++)
network->Simulate();
}
}
// allow units to reset
network->Reset();
/*if(i%50 == 0)
{
network->RecordAll();
if(mpiRank == 0)
cout<<"Storing.";
}*/
}
}
network->RecordAll();
}
void NetworkTests::NetworkTestMNISTClassification(int mpiRank, int mpiSize)
{
// Set up network
int nrColors = 2;
char* filenameTraining, *filenameTrainingLabels, *filenameTesting, *filenameTestingLabels;
int nrInputHypercolumns;
if( m_architecture == PC)
nrInputHypercolumns = 28*5;//28;
else if( m_architecture == BGL)
nrInputHypercolumns = 28*28;
int nrInputRateUnits = nrColors;
int nrMiddleHypercolumns = 16;
int nrMiddleRateUnits; // in each hypercolumn
int nrOutputHypercolumns = 1;
int nrOutputRateUnits;
if( m_architecture == PC)
{
nrMiddleRateUnits = 10;
nrOutputRateUnits = 10;
}
else if( m_architecture == BGL)
{
nrMiddleRateUnits = 256;
nrOutputRateUnits = 256;
}
Network* network = new Network();
network->SetMPIParameters(mpiRank,mpiSize);
PopulationColumns* layer1 = new PopulationColumns(network,nrInputHypercolumns,nrInputRateUnits,PopulationColumns::Graded); // input
PopulationColumns* layer2 = new PopulationColumns(network,nrMiddleHypercolumns,nrMiddleRateUnits,PopulationColumns::Graded); // middle
PopulationColumns* layer3 = new PopulationColumns(network,nrOutputHypercolumns,nrOutputRateUnits,PopulationColumns::Graded); // output
FullConnectivity* full2 = new FullConnectivity();
FullConnectivity* full4 = new FullConnectivity();
FullConnectivity* full5 = new FullConnectivity();
FullConnectivity* full6 = new FullConnectivity();
FullConnectivity* full8 = new FullConnectivity(true,"hypercolumn");
FullConnectivity* full10 = new FullConnectivity();
network->AddPopulation(layer1);
network->AddPopulation(layer2);
network->AddPopulation(layer3);
//layer1->AddPost(layer1,full3); // Recurrent, with MI minicolumn calculations
layer1->AddPre(layer1,full4); // Recurrent
//layer1->AddPost(layer1,full7); // Recurrent, with MI hypercolumn calculations + MDS
layer1->AddPre(layer1,full8); // Recurrent
//layer1->AddPost(layer2,full); // Feedforward, modified by VQ calculations and BCPNN
layer2->AddPre(layer1,full2); // Feedforward
//layer2->AddPost(layer2,full5); // Recurrent, with inhib BCPNN
layer2->AddPre(layer2,full6); // Recurrent
//layer2->AddPost(layer3,full9); // Feedforward, modified by Kussul or BCPNN calculations (supervised learning for classification)
layer3->AddPre(layer2,full10); // Feedforward
int mdsDimension = 5;
int miDimension = nrInputHypercolumns;
// MI
ProjectionModifierMIHypercolumn* miHypercolumns = new ProjectionModifierMIHypercolumn();
ProjectionModifierMIRateUnit* miRateUnits = new ProjectionModifierMIRateUnit(miHypercolumns);
full8->AddProjectionsEvent(miHypercolumns);
full4->AddProjectionsEvent(miRateUnits);
miRateUnits->AddParentProjectionModifier(miHypercolumns); // allows mi hypercolumns to have access to the belonging mi minicolumns (set as default?)
// MDS
LayerMDS* MDS = new LayerMDS(miDimension,mdsDimension, network);
ProjectionModifierMDS* mdsHypercolumns = new ProjectionModifierMDS();
layer1->AddPopulationModifier(MDS);
mdsHypercolumns->AddParentPopulationModifier(MDS); // allows MDS to have access to the hypercolumn event Projections (will be set as default)
full8->AddProjectionsEvent(mdsHypercolumns);
// VQ
int nrGroups = nrMiddleHypercolumns;
LayerVQ* VQ = new LayerVQ(nrGroups, LayerVQ::VQCSL);
full2->AddProjectionsEvent(VQ->GetProjectionModifier()); // Feedforward modified by VQ calculations
layer1->AddPopulationModifier(VQ);
VQ->AddChildPopulationModifier(MDS); // Allow VQ to have access to MDS output (m_Xi)
// Inhibitory bcpnn + feedforward bcpnn + softmax
float lambda0 = 10e-8;
float alpha = 0.05;//0.01;
float impactBeta = -0.1;//-0.03;//-0.01/nrMiddleRateUnits;
ProjectionModifierBcpnnOnline* bInhib = new ProjectionModifierBcpnnOnline(alpha,lambda0);
bInhib->SetImpactWeights(0.0);
bInhib->SetImpactBeta(impactBeta);
//// BGL - 40 patterns (32 nodes)
//float lambda0 = 10e-8;
//float alpha = 0.05;
//ProjectionModifierBcpnnOnline* bInhib = new ProjectionModifierBcpnnOnline(alpha,lambda0);
//bInhib->SetImpactWeights(0.0);
//bInhib->SetImpactBeta(-0.00001);
// PC - 10, 10 patterns
// float lambda0 = 10e-8;
//float alpha = 0.05;
//ProjectionModifierBcpnnOnline* bInhib = new ProjectionModifierBcpnnOnline(alpha,lambda0);
//bInhib->SetImpactWeights(0.0);
//bInhib->SetImpactBeta(-0.0001);
ProjectionModifierBcpnnOnline* bFeedforward = new ProjectionModifierBcpnnOnline(alpha,lambda0);
//bFeedforward->SetImpactBeta(0.0);
// full6->AddProjectionsEvent(bInhib);
// full2->AddProjectionsEvent(bFeedforward);
float clC = nrMiddleRateUnits*20;//*2;
ProjectionModifierCL* compLearn = new ProjectionModifierCL(nrMiddleRateUnits,0.0001,0.0005,clC);//nrMiddleRateUnits*100);
full2->AddProjectionsEvent(compLearn);
SoftMax* softmax = new SoftMax(1.0, SoftMax::WTA);
WTA* wta = new WTA();
layer2->AddPopulationModifier(wta);//wta);//softmax);
// Classification
SoftMax* softmaxOutput = new SoftMax(1.0, SoftMax::WTA);
ProjectionModifierBcpnnOnline* bClassification = new ProjectionModifierBcpnnOnline(0.05, 10e-3);
ProjectionModifierKussul* kClassification = new ProjectionModifierKussul();
//full10->AddProjectionsEvent(bClassification);
full10->AddProjectionsEvent(kClassification);
//layer3->AddPopulationModifier(softmaxOutput);
// Construct initial network
network->Initialize();
// Specify input data
Storage storageH5;
Storage storageLabels;
storageH5.SetMPIParameters(mpiRank,mpiSize);
storageLabels.SetMPIParameters(mpiRank,mpiSize);
if(m_architecture == BGL)
{
if(nrColors == 2)
{
filenameTraining = "/gpfs/scratch/s/simonbe/Databases/MNIST/MNIST_trainingData_2colors.csv";//MNIST_2colors.h5";
filenameTesting = "/gpfs/scratch/s/simonbe/Databases/MNIST/MNIST_testingData_2colors.csv";
}
else if(nrColors <= 0)
filenameTraining = "/gpfs/scratch/s/simonbe/Databases/MNIST/MNIST.h5";
filenameTrainingLabels = "/gpfs/scratch/s/simonbe/Databases/MNIST/MNIST_trainingLabels.csv";
filenameTestingLabels = "/gpfs/scratch/s/simonbe/Databases/MNIST/MNIST_testingLabels.csv";
}
else if(m_architecture == PC)
{
if(nrColors == 2)
{
filenameTraining = "C:\\CurrentProjects\\Network\\Databases\\MNIST\\MNIST_trainingData_2colors.csv";//MNIST_2colors.h5";
filenameTesting = "C:\\CurrentProjects\\Network\\Databases\\MNIST\\MNIST_testingData_2colors.csv";
}
else if(nrColors <= 0)
filenameTraining = "C:\\CurrentProjects\\Network\\Databases\\MNIST\\MNIST_trainingData.csv";//MNIST.h5";
filenameTrainingLabels = "C:\\CurrentProjects\\Network\\Databases\\MNIST\\MNIST_trainingLabels.csv";
filenameTestingLabels = "C:\\CurrentProjects\\Network\\Databases\\MNIST\\MNIST_testingLabels.csv";
}
vector<int> partsOfDataToUseAsInput = layer1->GetMPIDistributionHypercolumns(mpiRank);
vector<int> partsOfDataToUseAsOutput = vector<int>();//layer1->GetMPIDistributionHypercolumns(mpiRank);
// Training phase
int nrTrainImages;
int nrTestImages;
if( m_architecture == PC)
{
nrTrainImages = 10;
nrTestImages = 10;
}
else if( m_architecture == BGL)
{
nrTrainImages = 512;//10000;
nrTestImages = 10000;
}
vector<vector<float> > trainingData = storageH5.LoadDataFloatCSV(filenameTraining,nrTrainImages,true);//storageH5.LoadDataFloatHDF5(filename,"trainingData",0,nrTrainImages);//storageH5.LoadDataFloatHDF5(filename,"trainingData",partsOfDataToUseAsInput,0,nrTrainImages);
vector<vector<float> > trainingLabels = storageLabels.LoadDataFloatCSV(filenameTrainingLabels,nrTrainImages,true);
// Recordings
char name1[20];
sprintf(name1,"Projection%d_2.csv",mpiRank);
Meter connMeter(name1, Storage::CSV);
connMeter.AttachProjection(layer2->GetIncomingProjections()[0],0);//AttachUnit(layer1->GetRateUnits()[0]);
network->AddMeter(&connMeter);
char* name2 = "Layer2Activity_2.csv";
char* name3 = "Layer3Activity.csv";
char* nameTest2 = "Layer2Activity_test.csv";
char* nameTest3 = "Layer3Activity_test.csv";
Meter layerMeter(name2, Storage::CSV);
Meter layer3Meter(name3, Storage::CSV);
layerMeter.AttachPopulation(layer2);
network->AddMeter(&layerMeter);
layer3Meter.AttachPopulation(layer3);
network->AddMeter(&layer3Meter);
Meter vqMeter("vqGroups_2.csv", Storage::CSV);
vqMeter.AttachPopulationModifier((PopulationModifier*)VQ);//AttachUnit(layer1->GetRateUnits()[0]);
Meter miMeter("mds.csv",Storage::CSV);
miMeter.AttachObject((NetworkObject*)miHypercolumns, Meter::MeterPopulationModifier);
network->AddMeter(&vqMeter);
network->AddMeter(&miMeter);
int iterations = 30;
int stepsStimuliOn = 1;
// Training phase
// fixed will not allow RateUnits->Simulate in the layer
// will allow PopulationModifiers(!)
layer1->SwitchOnOff(false); // fixed during training phase
layer3->SwitchOnOff(false); // fixed during training phase (supervised)
int run = 3;
// switch off for some timesteps
mdsHypercolumns->SwitchOnOff(false);
MDS->SwitchOnOff(false);
VQ->SwitchOnOff(false);
bool areOff = true;
if(run == 2)
{
miHypercolumns->SwitchOnOff(false);
miRateUnits->SwitchOnOff(false);
}
else if(run == 1)
{
bInhib->SwitchOnOff(false);
bFeedforward->SwitchOnOff(false);
}
else if(run == 3)
{
kClassification->SwitchOnOff(false);
compLearn->SwitchOnOff(false);
VQ->SwitchOnOff(false);
}
// Semi-sequential version
// 1. Training phase
// 1A. Feature extraction
vector<float> binData;
vector<float> binDataOut;
for(int j=0;j<iterations;j++)
{
for(int i=0;i<nrTrainImages;i++)
{
if(run == 3 && i == 0)
{
if(j == (int)(iterations*0.3))
{
mdsHypercolumns->SwitchOnOff(true);
MDS->SwitchOnOff(true);
if(mpiRank == 0)
miMeter.RecordAll(0);
}
if(j == (int)(iterations*0.5))
{
miHypercolumns->SwitchOnOff(false);
miRateUnits->SwitchOnOff(false);
mdsHypercolumns->SwitchOnOff(false);
MDS->SwitchOnOff(false);
}
if(j == (int)(iterations*0.5+2))
{
VQ->SwitchOnOff(true);
kClassification->SwitchOnOff(true);
compLearn->SwitchOnOff(true);
layer3->SwitchOnOff(true);
}
}
if(j == 35 && run == 1)
{
mdsHypercolumns->SwitchOnOff(true);
MDS->SwitchOnOff(true);
areOff = false;
}
if(j == 50 && run == 1)//50)
{
VQ->SwitchOnOff(true);
}
if(mpiRank == 0)
{
cout<<i<<"("<<j<<") ";
cout.flush();
}
binData = toBinary(trainingData[i],trainingData[i].size(), nrInputRateUnits);//vector<float> binData = toBinary(currentTrainingData[0],currentTrainingData[0].size(),nrInputRateUnits);//trainingData[i],trainingData[i].size(), nrInputRateUnits);
layer1->SetValuesAll(binData);
binDataOut = toBinary(trainingLabels[i],trainingLabels[i].size(), nrOutputRateUnits);
layer3->SetValuesAll(binDataOut);
if(run == 2 || run == 3)
{
int modSize;
int plastStopIter = -1;
if(m_architecture == PC)
{
modSize = 100;//10;
plastStopIter = int(iterations*0.8f);
}
else
{
modSize = 100;
plastStopIter = iterations*1;//*0.7;
}
if(j%modSize == 0 && j!=0 && compLearn->IsOn())
{
alpha = alpha/2;
impactBeta = impactBeta/2;
bFeedforward->SetAlpha(alpha);
bInhib->SetImpactBeta(impactBeta);
clC = clC*0.7f;
compLearn->SetC(clC);
//bInhib->SetImpactBeta(0.0);
//softmax->SetType(false);
}
if(j==plastStopIter)
{
bFeedforward->SwitchOnOff(false);//SetAlpha(0.0);
bInhib->SwitchOnOff(false);//SetImpactBeta(0.0);
softmax->SetType(SoftMax::WTA);
}
}
// next time step
network->Simulate();
cout.flush();
}
connMeter.RecordAll(0);
if(mpiRank == 0)
{
cout<<"\n";
cout.flush();
layerMeter.RecordAll(0);
layer3Meter.RecordAll(0);
}
}
// save data
if(mpiRank == 0)
vqMeter.RecordAll(0);
// 2. Testing phase
//network->Simulate();
network->Reset(); // Clears values
//network->Simulate();
//network->Simulate();
layer1->SwitchOnOff(false);
layer3->SwitchOnOff(true);
bFeedforward->SwitchOnOff(false);//->SetAlpha(0.0);
bClassification->SwitchOnOff(false);
kClassification->SwitchOnOff(false);
bInhib->SwitchOnOff(false);//SetImpactBeta(0.0);
softmax->SetType(SoftMax::WTA);
vector<vector<float> > testingData = storageH5.LoadDataFloatCSV(filenameTesting,nrTestImages,true);//storageH5.LoadDataFloatHDF5(filename,"trainingData",0,nrTrainImages);//storageH5.LoadDataFloatHDF5(filename,"trainingData",partsOfDataToUseAsInput,0,nrTrainImages);
vector<vector<float> > testingLabels = storageLabels.LoadDataFloatCSV(filenameTestingLabels,nrTestImages,true);
// A. Training data
for(int i=0;i<nrTrainImages;i++)
{
if(mpiRank == 0)
{
cout<<i;
cout.flush();
}
binData = toBinary(trainingData[i],trainingData[i].size(), nrInputRateUnits);//vector<float> binData = toBinary(currentTrainingData[0],currentTrainingData[0].size(),nrInputRateUnits);//trainingData[i],trainingData[i].size(), nrInputRateUnits);
binDataOut = toBinary(trainingLabels[i],trainingLabels[i].size(), nrOutputRateUnits);
layer1->SetValuesAll(binData);
network->Simulate();
}
network->Reset(); // Clears values
if(mpiRank == 0)
{
layerMeter.RecordAll(0);
layer3Meter.RecordAll(0);
}
layerMeter.SetFilename(nameTest2);
layer3Meter.SetFilename(nameTest3);
// B. Testing data
for(int i=0;i<nrTestImages;i++)
{
if(mpiRank == 0)
{
cout<<i;
cout.flush();
}
binData = toBinary(testingData[i],testingData[i].size(), nrInputRateUnits);//vector<float> binData = toBinary(currentTrainingData[0],currentTrainingData[0].size(),nrInputRateUnits);//trainingData[i],trainingData[i].size(), nrInputRateUnits);
binDataOut = toBinary(testingLabels[i],testingLabels[i].size(), nrOutputRateUnits);
layer1->SetValuesAll(binData);
network->Simulate();
}
if(mpiRank == 0)
{
layerMeter.SetFilename(nameTest2);
layer3Meter.SetFilename(nameTest3);
layerMeter.RecordAll(0);
layer3Meter.RecordAll(0);
}
}
