void mkimg(char *cfgfile, char *weightfile, int h, int w, int num, char *prefix)
{
network *net = load_network(cfgfile, weightfile, 0);
image *ims = get_weights(net->layers[0]);
int n = net->layers[0].n;
int z;
for(z = 0; z < num; ++z){
image im = make_image(h, w, 3);
fill_image(im, .5);
int i;
for(i = 0; i < 100; ++i){
image r = copy_image(ims[rand()%n]);
rotate_image_cw(r, rand()%4);
random_distort_image(r, 1, 1.5, 1.5);
int dx = rand()%(w-r.w);
int dy = rand()%(h-r.h);
ghost_image(r, im, dx, dy);
free_image(r);
}
char buff[256];
sprintf(buff, "%s/gen_%d", prefix, z);
save_image(im, buff);
free_image(im);
}
free_network(net);
}
image *visualize_convolutional_layer(convolutional_layer l, char *window, image *prev_weights)
{
image *single_weights = get_weights(l);
show_images(single_weights, l.n, window);
image delta = get_convolutional_image(l);
image dc = collapse_image_layers(delta, 1);
char buff[256];
//sprintf(buff, "%s: Output", window);
//show_image(dc, buff);
//save_image(dc, buff);
free_image(dc);
return single_weights;
}
void NETWORK::rewire( int _laps )
{
// weights
std::vector<double> weights;
get_weights( weights );
shuffle_vector( weights );
// structure
int wirings_left = _laps;
int s1, s2, deg1, deg2, p1, p2, t1, t2;
while( wirings_left > 0 )
{
// choose two edge randomly
s1 = Ran.IRandom( 0, Order-1 );
deg1 = Nodes[s1]->outdegree();
s2 = Ran.IRandom( 0, Order-1 );
deg2 = Nodes[s2]->outdegree();
if( s1 != s2 && deg1 != 0 && deg2 != 0 )
{
p1 = Ran.IRandom( 0, deg1-1 );
t1 = Nodes[s1]->outneighbor(p1)->id();
p2 = Ran.IRandom( 0, deg2-1 );
t2 = Nodes[s2]->outneighbor(p2)->id();
if( t1 != t2 && t1 != s2 && t2 != s1 )
{
remove_edge( s1, t1 );
remove_edge( s2, t2 );
add_edge( s1, t2, 1.0 );
add_edge( s2, t1, 1.0 );
wirings_left--;
}
}
}
// set weights
int deg;
for(int i=0; i<Order; i++)
{
deg = Nodes[i]->outdegree();
for(int j=0; j<deg; j++)
{
Nodes[i]->setOutWeight( j, weights.back() );
weights.pop_back();
}
}
}
/*
* Determines whether a connection is possible between
* pairs of local and remote interfaces. To determine
* reachability, the kernel's routing table is queried.
* Higher weightings are given to connections on the same
* network.
*/
static opal_reachable_t* netlink_reachable(opal_list_t *local_if,
opal_list_t *remote_if)
{
opal_reachable_t *reachable_results = NULL;
int i, j;
opal_if_t *local_iter, *remote_iter;
reachable_results = opal_reachable_allocate(local_if->opal_list_length,
remote_if->opal_list_length);
if (NULL == reachable_results) {
return NULL;
}
i = 0;
OPAL_LIST_FOREACH(local_iter, local_if, opal_if_t) {
j = 0;
OPAL_LIST_FOREACH(remote_iter, remote_if, opal_if_t) {
reachable_results->weights[i][j] = get_weights(local_iter, remote_iter);
j++;
}
