double Community::one_level()
{
bool improvement = false;
int nb_pass_done = 0;
double new_mod = modularity();
double cur_mod = new_mod;
// repeat while
// there is an improvement of modularity
// or there is an improvement of modularity greater than a given epsilon
// or a predefined number of pass have been done
do
{
cur_mod = new_mod;
improvement = false;
nb_pass_done++;
// for each node: remove the node from its community and insert it in the best community
for (int node_tmp = 0; node_tmp < g->n; node_tmp++)
{
int node = node_tmp;
int node_comm = n2c[node];
// computation of all neighboring communities of current node
map<int, double> ncomm = neigh_comm(node);
// remove node from its current community
remove(node, node_comm, ncomm[node_comm]);
// compute the nearest community for node
// default choice for future insertion is the former community
int best_comm = node_comm;
double best_nblinks = 0;
double best_increase = 0;
for (auto iter = ncomm.begin(); iter != ncomm.end(); iter++)
{
int new_comm = (*iter).first;
double increase = gain_modularity(node, new_comm, ncomm[new_comm]);
if (increase > best_increase + 1e-8)
{
best_comm = new_comm;
best_nblinks = ncomm[new_comm];
best_increase = increase;
}
}
insert(node, best_comm, best_nblinks);
if (best_comm != node_comm)
improvement = true;
}
new_mod = modularity();
//cerr << "pass number " << nb_pass_done << " of " << nb_pass << " : " << new_mod << " " << cur_mod << endl;
}
while (improvement && new_mod - cur_mod > 1e-6);
return new_mod;
}
double CommunitySpace::fast_unfolding_step(double epsilon_modularity, int lambda) {
int iterations = 0;
int actual_group;
int best_community, best_nblinks;
double best_increase, increase;
bool improvement = false;
double q = modularity();
double actual_modularity = q;
//cout << "Initial modularity: " << q << endl;
do {
actual_modularity = q;
improvement = false;
//First, go througout the nodes and change their groups
Iterator<node>*nodes = theGraph->getNodes();
map<int, int>::iterator it;
while (nodes->hasNext()) {
//The actual node
node actual = nodes->next();
actual_group = groups[actual.id];
map<int, int> neighs_communities = neighbor_communities(actual);
//Remove the node from its community
remove_node(actual, actual_group, neighs_communities[actual_group]);
//Actual state
best_community = actual_group;
best_nblinks = neighs_communities[actual_group];
best_increase = 0;
increase = 0;
//Search through the neighbors
for (it = neighs_communities.begin(); it != neighs_communities.end(); it++) {
int neigh_community = 0;
neigh_community = (*it).first;
int nb_links = neighs_communities[neigh_community];
increase = modularity_gain(actual, neigh_community, nb_links);
if (increase > best_increase) {
best_increase = increase;
best_nblinks = nb_links;
best_community = neigh_community;
}
}
//Now, move actual node to the community of each neighbor
insert_node(actual, best_community, best_nblinks);
if (best_community != actual_group) {
improvement = true;
}
q = modularity();
}
q = modularity();
iterations++;
delete nodes;
} while (improvement && q - actual_modularity > epsilon_modularity && iterations < lambda);
//cout << "Step modularity " << q << endl;
//q va a tener la mejor modularidad
return q;
}
double CommunitySpace::execute_fast_unfolding(double epsilon_modularity, int lambda_step, int lambda_local) {
int counter = 0;
double actual_q = modularity();
//long start_time,end_time;
//start_time = clock();
double q = fast_unfolding_step(epsilon_modularity, lambda_step);
//end_time = clock();
//cout << "The first step took "<< (float)(end_time-start_time)/(float)CLOCKS_PER_SEC << " seconds.\n";
while (q - actual_q > epsilon_modularity && counter < lambda_local) {
//Convert the partition to meta nodes and meta-edges
//start_time = clock();
compressTheGraph();
//end_time = clock();
//cout << "Compressing the graph took "<< (float)(end_time-start_time)/(float)CLOCKS_PER_SEC << " seconds.\n";
//Redo the fast unfolding step with the new graph
actual_q = q;
//start_time = clock();
q = fast_unfolding_step(epsilon_modularity, lambda_step);
//end_time = clock();
//cout << "Pass " << counter <<" took "<< (float)(end_time-start_time)/(float)CLOCKS_PER_SEC << " seconds.\n";
counter++;
}
return q;
}
void testModularity() {
// We need to read the network from a file: testIO() must have been passed
log("TESTING measures");
log("Reading the network...",false);
// Creating an empty multiple network and initializing it
MultipleNetwork mnet_toy;
mnet_read_edgelist(mnet_toy, "test/toy.mnet");
mnet_toy.getNetwork("l1")->addVertex("U4");
mnet_toy.map("U4","U4","l1");
MultipleNetwork mnet0;
//mnet_read_edgelist(mnet, "test/toy.mnet");
mnet_read_edgelist(mnet0, "/Users/matteomagnani/Dropbox/Research/13NetworkScience/code/fig6b.mnet");
mnet0.getNetwork("l1")->addVertex("v8");
mnet0.map("v8","v8","l1");
mnet0.getNetwork("l3")->addVertex("v8");
mnet0.map("v8","v8","l3");
MultipleNetwork mnet;
//mnet_read_edgelist(mnet, "test/toy.mnet");
mnet_read_edgelist(mnet, "/Users/matteomagnani/Dropbox/Research/13NetworkScience/code/fig6b.mnet");
mnet.getNetwork("l1")->addVertex("v8");
mnet.map("v8","v8","l1");
mnet.getNetwork("l3")->addVertex("v8");
mnet.map("v8","v8","l3");
log("done!");
log("Computing modularity...");
std::map<network_id,std::map<vertex_id,long> > groups_toy, groups1, groups2, groups3, groups4;
groups_toy[0][0]=0;
groups_toy[0][1]=0;
groups_toy[0][2]=0;
groups_toy[0][3]=1;
groups_toy[0][4]=1;
groups_toy[1][1]=1;
groups_toy[1][3]=1;
groups_toy[1][4]=1;
groups1[0][0]=0;
groups1[0][1]=0;
groups1[0][2]=0;
groups1[0][3]=1;
groups1[0][4]=1;
groups1[0][6]=1;
groups1[0][7]=1;
groups1[1][0]=0;
groups1[1][1]=0;
groups1[1][2]=0;
groups1[1][3]=1;
groups1[1][4]=1;
groups1[1][5]=1;
groups1[1][6]=1;
groups1[1][7]=1;
groups1[2][0]=0;
groups1[2][1]=0;
groups1[2][2]=0;
groups1[2][3]=1;
groups1[2][4]=1;
groups1[2][5]=1;
groups1[2][6]=1;
groups1[2][7]=1;
groups2[0][0]=0;
groups2[0][1]=0;
groups2[0][2]=0;
groups2[0][3]=1;
groups2[0][4]=0;
groups2[0][6]=1;
groups2[0][7]=1;
groups2[1][0]=0;
groups2[1][1]=0;
groups2[1][2]=0;
groups2[1][3]=1;
groups2[1][4]=1;
groups2[1][5]=1;
groups2[1][6]=1;
groups2[1][7]=1;
groups2[2][0]=0;
groups2[2][1]=0;
groups2[2][2]=0;
groups2[2][3]=0;
groups2[2][4]=1;
groups2[2][5]=1;
groups2[2][6]=1;
groups2[2][7]=1;
groups3[0][0]=0;
groups3[0][1]=1;
groups3[0][2]=0;
groups3[0][3]=1;
groups3[0][4]=0;
groups3[0][6]=0;
groups3[0][7]=1;
groups3[1][0]=0;
groups3[1][1]=1;
groups3[1][2]=0;
groups3[1][3]=1;
groups3[1][4]=0;
groups3[1][5]=1;
groups3[1][6]=0;
groups3[1][7]=1;
groups3[2][0]=0;
groups3[2][1]=1;
groups3[2][2]=0;
groups3[2][3]=1;
groups3[2][4]=0;
groups3[2][5]=1;
groups3[2][6]=0;
groups3[2][7]=1;
groups4[0][0]=0;
groups4[0][1]=1;
groups4[0][2]=0;
groups4[0][3]=1;
groups4[0][4]=0;
groups4[0][6]=0;
groups4[0][7]=1;
groups4[1][0]=1;
groups4[1][1]=0;
groups4[1][2]=1;
groups4[1][3]=0;
groups4[1][4]=1;
groups4[1][5]=0;
groups4[1][6]=1;
groups4[1][7]=0;
groups4[2][0]=0;
groups4[2][1]=1;
groups4[2][2]=0;
groups4[2][3]=1;
groups4[2][4]=0;
groups4[2][5]=1;
groups4[2][6]=0;
groups4[2][7]=1;
double mod = modularity(mnet_toy,groups_toy,1);
log(std::to_string(mod) + " ",false);
log("done 1 - toy!");
log("GR1!");
mod = modularity(mnet0,groups1,0);
log(std::to_string(mod) + " ",false);
log("done 0!");
mod = modularity(mnet0,groups1,.5);
log(std::to_string(mod) + " ",false);
log("done .5!");
mod = modularity(mnet0,groups1,1);
log(std::to_string(mod) + " ",false);
log("done 1!");
log("GR2!");
mod = modularity(mnet,groups2,0);
log(std::to_string(mod) + " ",false);
log("done 0!");
mod = modularity(mnet,groups2,.5);
log(std::to_string(mod) + " ",false);
log("done .5!");
mod = modularity(mnet,groups2,1);
log(std::to_string(mod) + " ",false);
log("done 1!");
log("GR3!");
mod = modularity(mnet,groups3,0);
log(std::to_string(mod) + " ",false);
log("done 0!");
mod = modularity(mnet,groups3,.5);
log(std::to_string(mod) + " ",false);
log("done .5!");
mod = modularity(mnet,groups3,1);
log(std::to_string(mod) + " ",false);
log("done 1!");
log("GR4!");
mod = modularity(mnet,groups4,0);
log(std::to_string(mod) + " ",false);
log("done 0!");
mod = modularity(mnet,groups4,.5);
log(std::to_string(mod) + " ",false);
log("done .5!");
mod = modularity(mnet,groups4,1);
log(std::to_string(mod) + " ",false);
log("done 1!");
log("TEST SUCCESSFULLY COMPLETED (modularity)");
}
