neuron | Neuron : Nervos CKB Wallet | Blockchain library

We can try the code below using optimize

It looks like, in calculate_community_modularity, you use greedy_modularity_communities to create a dict, modularity_dict, which maps a node in your graph to a community. If I understand correctly, you can take each subgraph community in modularity_dict and pass it into shannon_entropy to calculate the entropy for that community.

this is pseudo code, so there may be some errors. This should convey the principle, though.

after running calculate_community_modularity, you have a dict like this, where the key is each node, and the value is that which the community belongs to

for the "k" metric:

It may be useful to step through the model inputs/outputs in detail.

When using the keras.layers.SimpleRNN layer with return_sequences=True, the output will return a 3-D tensor where the 0th axis is the batch size, the 1st axis is the timestep, and the 2nd axis is the number of hidden units (in the case for both SimpleRNN layers in your model, 10).

The Conv1D layer will produce an output tensor where the last dimension becomes the number of hidden units (in the case for your model, 16), as it's just being convolved with the input.

keras.layers.TimeDistributed, the layer supplied (in the example provided, Dense(1)) will be applied to each timestep in the batch independently. So with 96 timesteps, we have 96 outputs for each record in the batch.

So stepping through your model:

You did not move your model to device, only the data. You need to call model.to(device) before using it with data located on device.

This is not really a programming question, but I will try to answer it. The webpage with the data sources states that the adjacent matrix files for brain samples give distances between connected nodes expressed in pixels of the images used to reconstruct the networks. The paper then explains that to get the real adjacency matrix Mij (with 0 and 1 values only) the authors consider as connected nodes where the distance is at most 16 micrometers. I don't see the information on how many pixels in the image corresponds to one micrometer. This would be needed to compute the same matrix Mij that the authors used in their calculations.

Furthermore, the value〈k〉is not the degree centrality or the clustering coefficient (that depend on a node), but rather the average number of connections per node in the network, computed using the matrix Mij. The paper then compares the observed distributions of degree centralities and clustering coefficients in the brain and cosmic networks to the distribution one would see in a random network with the same number of nodes and the same value of〈k〉. The conclusion is that brain and cosmic networks are highly non-random.

Edits:

1. The conversion of 0.32 micrometers per pixel seems to be right. In the files with data on brain samples (both for cortex and cerebellum) the largest value is 50 pixels, which with this conversion corresponds to 16 micrometers. This suggests that the authors of the paper already thresholded the matrices, listing in them only distances not exceeding 16 micrometers. In view of this, to obtain the matrix Mij with 0 and 1 values only, one simply needs to replace all non-zero values with 1. An issue is that using the matrices obtained in this way one gets 〈k〉 = 9.22 for cerebellum and 〈k〉 = 7.13 for cortex, which is somewhat outside the ranges given in the paper. I don't know how to account for this discrepancy.

2. Negative centrality values are due to a mistake (missing parentheses) in the code. It should be:

So I accidentally removed this line from df_to_dataset function:

You could set up your objective function as follows:

Looks great, as you have already followed most of the solutions to resolve gradient exploding problem. Below is the list of all solutions you can try

Solutions to avoid Gradient Exploding problem

1. Appropriate Weight initialization: utilise appropriate weight Initialization based on the activation function used.

   Initialization Activation Function He ReLU & variants LeCun SELU Glorot Softmax, Logistic, None, Tanh

2. Redesigning your Neural network: use fewer layers in neural network and/or use smaller batch size

3. Choosing Non Saturation activation function: choose the right activation function with reduced learning rates

   • ReLU
   • Leaky ReLU
   • randomized leaky ReLU (RReLU)
   • parametric leaky ReLU (PReLU)
   • exponential linear unit (ELU)

4. Batch Normalisation: Ideally using batch normalisation before/after each layer, based on what works best for your dataset.

   • after each layer Paper reference