Esempio n. 1
0
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();
}
Esempio n. 2
0
void NetworkTests::NetworkTestIF(int mpiRank,int mpiSize)
{
	Network* network = new Network();
	network->SetMPIParameters(mpiRank,mpiSize);

	int nrHypercolumns = 2;
	int nrRateUnits = 2;

	PopulationColumns* layer1 = new PopulationColumns(network,nrHypercolumns,nrRateUnits,PopulationColumns::IF);
	PopulationColumns* layer2 = new PopulationColumns(network,nrHypercolumns,nrRateUnits,PopulationColumns::IF);

	FullConnectivity* full = new FullConnectivity();
	FullConnectivity* full2 = new FullConnectivity();

	FullConnectivity* full3 = new FullConnectivity();
	FullConnectivity* full4 = new FullConnectivity();
	
	network->AddPopulation(layer1);
	network->AddPopulation(layer2);

	//layer1->AddPost(layer2,full); // Feedforward layer 1 -> layer 2
	layer2->AddPre(layer1,full2);

	//layer1->AddPost(layer1,full3); // Recurrent layer 1 -> layer 1
	layer1->AddPre(layer1,full4);

	float lambda0 = 0.0001f;
	float alpha = 0.01f;
	ProjectionModifierBcpnnOnline* bRecL1 = new ProjectionModifierBcpnnOnline(alpha,lambda0);
	bRecL1->SetImpactBeta(-1);
	bRecL1->SetImpactWeights(-1);
	full4->AddProjectionsEvent(bRecL1);

	// Construct initial network
	network->Initialize();

	// Recordings
	Meter unitMeter("unit1.csv", Storage::CSV);
	unitMeter.AttachUnit(layer1->GetRateUnits()[0]);
	network->AddMeter(&unitMeter);

	int timesteps = int(1e3);
	int nrPatterns = 4;
	vector<vector<float> > patterns(nrPatterns);
	vector<float> p1(8), p2(8), p3(8), p4(8);
	p1[0] = 1.0; p1[1] = 1.0; p1[2] = 0.0; p1[3] = 0.0; p1[4] = 1.0; p1[5] = 1.0; p1[6] = 0.0; p1[7] = 0.0; // 1100 1100
	p2[0] = 0.0; p2[1] = 1.0; p2[2] = 1.0; p2[3] = 0.0; p2[4] = 0.0; p2[5] = 1.0; p2[6] = 1.0; p2[7] = 0.0; // 0110 0110
	p3[0] = 0.0; p3[1] = 0.0; p3[2] = 1.0; p3[3] = 1.0; p3[4] = 0.0; p3[5] = 0.0; p3[6] = 1.0; p3[7] = 1.0; // 0011 0011
	p4[0] = 1.0; p4[1] = 0.0; p4[2] = 0.0; p4[3] = 1.0; p4[4] = 1.0; p4[5] = 0.0; p4[6] = 0.0; p4[7] = 1.0; // 1001 1001

	patterns[0] = p1;
	patterns[1] = p2;
	patterns[3] = p3;
	patterns[4] = p4;

	// initial training phase (separated atm)
	layer1->SwitchOnOff(false);

	int iterations = 100;
	int stepsEach = 5;
	for(int i=0;i<iterations;i++)
	{
		for(int j=0;j<stepsEach;j++)
		{
			layer1->SetValuesAll(patterns[i%nrPatterns]);
		}
	}

	// free running
	layer1->SwitchOnOff(true);
	
	for(int i=0;i<timesteps;i++)
	{
		if(i%10 == 0)
		{
			layer1->SetValuesAll(patterns[0]);
		}
		else if(i%5 == 0)
		{
			layer1->SetValuesAll(patterns[1]);
		}

		network->Simulate();
	}
}
Esempio n. 3
0
void NetworkTests::NetworkTestInclTimingBCPNNRecurrent()
{
	int nrHypercolumns = 65536;//65536;//128*16*10;//128*16*10;//128*16*10;//128*16;
	int nrRateUnits = 100;//50;//100;//100;//40;//10
	//float activity = 0.05;
	int nrItems = 5;
	bool storeData = false;
	float probConnectivity = 0.0003;//0.00005;//0.000025;//0.00003;//0.000025;//0.001;//0.00044;//0.00011;//0.00024;//0.00006;//0.0004;//0.00001;
	bool doTesting = true; // false for some scaling tests

	// network construction
	Network* network = new Network();
	network->AddTiming(network);

	PopulationColumns* layer1 = new PopulationColumns(network,nrHypercolumns,nrRateUnits,PopulationColumns::Graded);
	network->AddPopulation(layer1);
	
	FullConnectivity* full = new FullConnectivity();//false,"minicolumns");
	full->SetRandomWeights(0,0);
	RandomConnectivity* randConn = new RandomConnectivity(probConnectivity);//0.1);
	randConn->SetRandomWeights(0,0);	
	//network->AddTiming(randConn);
	
	layer1->AddPre(layer1,randConn); // recurrent

	// Add Projection changes
	float lambda0 = 10e-6;
	float alpha = 0.05;
	ProjectionModifierBcpnnOnline* bStandard = new ProjectionModifierBcpnnOnline(alpha,lambda0);
	
	//full->AddProjectionsEvent(bStandard);
	randConn->AddProjectionsEvent(bStandard);

	WTA* wta = new WTA();
	layer1->AddPopulationModifier(wta);

	// Construct initial network
	network->Initialize();
	//vector<int> partsOfDataToUseAsInput = layer1->GetMPIDistribution(network->MPIGetNodeId());

	// Specify input data
	// - change to only create local part
	DataSources source;
	// not correct right now as SetValuesAll working locally and this is global
	vector<vector<float> > data = source.GetRandomHCsOrthogonal(nrHypercolumns/100,nrRateUnits,nrItems);

	// Meters
	Meter* l1meter = new Meter("layer1.csv", Storage::CSV);
	if(storeData)
	{
		l1meter->AttachPopulation(layer1);
		network->AddMeter(l1meter);
	}

	Meter* c1meter = new Meter("Projections1.csv",Storage::CSV);
	if(storeData)
	{
		c1meter->AttachProjection(layer1->GetIncomingProjections()[0],0);
		network->AddMeter(c1meter);
	}

	// Timings
	network->AddTiming(bStandard);
	network->AddTiming(layer1);
	network->AddTiming(full);

	// need to access after it has been built
	network->AddTiming(layer1->GetIncomingProjections()[0]);

	// Training
	// set fixed pattern
	layer1->SwitchOnOff(false);

	int trainIterations = 1;
	int testIterations = 5;

	for(int i=0;i<trainIterations;i++)
	{
		//cout<<i<<"\n";

		for(int j=0;j<data.size();j++)
		{
			layer1->SetValuesAll(data[j]);

			// next time step
			network->Simulate(10);
		}
	}

	// Testing
	if(doTesting == true)
	{
		layer1->SwitchOnOff(true);
		bStandard->SwitchOnOff(false);

		for(int i=0;i<testIterations;i++)
		{
			for(int j=0;j<data.size();j++)
			{
				// clear all events before switching so no disturbance, can remove if moving average activity etc.
				network->ClearEventsIncoming();

				layer1->SetValuesAll(data[j]);
				network->Simulate(10);

				//for(int i=0;i<testIterations;i++)
				// next time step
				//			network->Simulate();
			}
		}
	}
	
	network->RecordAll();
	network->StoreAnalysis();
}
Esempio n. 4
0
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);
	}
}
Esempio n. 5
0
// Switching
void NetworkTests::NetworkTestSwitching(int mpiRank, int mpiSize)
{
	int nrHypercolumns = 5;
	int nrRateUnits = 10;
	int nrItems = 2;

	DataSources sources;
	srand(2);
	vector<vector<float> > data = sources.GetRandomHCs(nrHypercolumns,nrRateUnits,nrItems);//sources.GetRandom(size,0.1,nrItems);
	
	// setup recurrent network

	Network* network = new Network();
	network->SetMPIParameters(mpiRank,mpiSize);

	PopulationColumns* layer1 = new PopulationColumns(network,nrHypercolumns,nrRateUnits,PopulationColumns::Graded);
	FullConnectivity* full = new FullConnectivity();//FullConnectivity(false,"");

	layer1->AddPre(layer1,full);
	network->AddPopulation(layer1);

	ProjectionModifierBcpnnOnline* eBcpnn = new ProjectionModifierBcpnnOnline();
	ProjectionModifierTriesch* eTriesch = new ProjectionModifierTriesch();
	ProjectionModifierHebbSimple* eHebb = new ProjectionModifierHebbSimple();
	ProjectionModifierBCM* eBCM = new ProjectionModifierBCM();

	full->AddProjectionsEvent(eBcpnn);		// incl adding transfer fcn
	//full->AddProjectionsEvent(eTriesch);		// incl adding transfer fcn
	//full->AddProjectionsEvent(eHebb);
	//full->AddProjectionsEvent(eBCM);

	PopulationModifierAdaptation2* eAdaptation = new PopulationModifierAdaptation2();
	//eAdaptation->SetParameters(0,0); 		// adaptation off initially	
	eAdaptation->SetParameters(0); 		// adaptation off initially
	layer1->AddPopulationModifier(eAdaptation);
	
	WTA* wta = new WTA();
	layer1->AddPopulationModifier(wta);//wta);//softmax);

	network->Initialize();
	eAdaptation->Initm_Aj(1); // initialize m_Aj vector

	// set up meters
	char* name1 = new char[30];
	char* name2 = new char[30];
	char* name3 = new char[30];
	sprintf(name1,"Projections_n%d.csv",mpiRank);
	sprintf(name2,"Layer1ActivityWTA.csv");
	sprintf(name3,"Layer1Activity.csv");

	Meter* connMeter = new Meter(name1, Storage::CSV);
	connMeter->AttachProjection(layer1->GetIncomingProjections()[0],0);
	network->AddMeter(connMeter);

	Meter* layerMeter = new Meter(name3, Storage::CSV);
	layerMeter->AttachPopulation(layer1);
	network->AddMeter(layerMeter);

	Meter* eventLayerMeter=new Meter(name2, Storage::CSV);
	eventLayerMeter->AttachPopulationModifier(eAdaptation);
	network->AddMeter(eventLayerMeter);

	int nrIters = 10;
	int stimuliOn = 10;

	layer1->SwitchOnOff(false); // fixed input

	// store patterns
	for(unsigned int i=0;i<nrIters;i++)
	{
		for(unsigned int j=0;j<data.size();j++)
		{
			for(unsigned int k=0;k<stimuliOn; k++)
			{
				layer1->SetValuesAll(data[j]);
				network->Simulate();
			}
		}
	}


	// random stimulation
	vector<float> randVec(data[0].size());
	for(unsigned int i=0;i<randVec.size();i++)
		randVec[i] = 0.5f*float(rand()/RAND_MAX);

	// mixture
	vector<float> mixVec(data[0].size());
	for(unsigned int i=0;i<mixVec.size();i++)
		mixVec[i] = 1*(data[0][i] + data[1][i]);

	layer1->SetValuesAll(mixVec);//randVec);

	// Test without adaptation turned on

	layer1->SwitchOnOff(true);
	//eHebb->SetEtaHebb(0.0);
	eBCM->SwitchOnOff(false);
	eBcpnn->SwitchOnOff(false);

	for(int i=0;i<nrIters;i++)
	{
		for(unsigned int j=0;j<data.size();j++)
		{
			layer1->SetValuesAll(mixVec);//data[j]);
			for(int k=0;k<stimuliOn; k++)
			{	
				network->Simulate();
			}
		}
	}

	// Turn on adaptation
	//eAdaptation->SetParameters(10,0.2);
	eAdaptation->SetParameters(0.2f);

	for(int i=0;i<nrIters;i++)
	{
		for(unsigned int j=0;j<data.size();j++)
		{
			layer1->SetValuesAll(mixVec);
			for(int k=0;k<stimuliOn; k++)
			{	
				network->Simulate();
			}
		}
	}

	network->RecordAll();

	// check switching
}