Hi Tiago,
sometimes, when delete the graph and create a new one, then plot it, the
plotted graph is shown upside down (in terms of the node text). So how could
we control the orientation of the graph? Or which parameter we should use to
always make node text shown in a correct orientation. Thanks a lot.
--
View this message in context: http://main-discussion-list-for-the-graph-tool-project.982480.n3.nabble.com…
Sent from the Main discussion list for the graph-tool project mailing list archive at Nabble.com.

Hi,
I'm suffering from the same issue mentioned in this post:
https://git.skewed.de/count0/graph-tool/issues/174
Namely, I'm trying to draw a graph that includes a lot of self-looping
edges, and my labels are being printed upside down. If I remove the
self-loops the labels are shown the right way up.
Is there a fix for it?
Thanks,
Charlie
--
View this message in context: http://main-discussion-list-for-the-graph-tool-project.982480.n3.nabble.com…
Sent from the Main discussion list for the graph-tool project mailing list archive at Nabble.com.

Dear Tiago,
I have a directed graph of about half a million nodes and approximately a
million edges following scale free behaviour and a power law degree
distribution. To test some of my hypothesis, I would like to generate random
smaller graphs (about 50 up to 200 nodes) representative of the big one.
When I used a sample function that samples straight away from the real
distribution of the big network, I have following problems:
- I generate unconnected nodes with both 0 in AND out degree.
- I generate small sub parts of a few nodes that are not connected to the
main graph.
- If only sampling from nodes with at least 1 degree, the generated graph is
coherent, but not representative anymore as I need a big portion of nodes
with either only one in or one out degree.
Here is the part of my script I used for that, where samples are drawn from
dictionaries of the degrees:
def sample_in():
a=np.random.randint(num)
k_in = in_degrees[a]
return k_in
def sample_out():
if sample_in()==0:
b=np.random.randint(num_out)
k_out=out_zero_zeros.values()[b]
return k_out
else:
b=np.random.randint(num)
k_out=out_degrees[b]
return k_out
N=200
g=gt.random_graph(N, lambda:(sample_in(), sample_out()),
model="constrained-configuration", directed=True)
I also tried sampling from a list of tuples as you have mentioned before in
the forum, but I didn't receive any results, as the tuples randomly drawn
from my list might not be combinable.
degs=[(7,1),(4,3),(5,6),(2,4),(6,8),(2,0),(3,5),(0,3),(2,7),(2,1)]
g = gt.random_graph(4, lambda i: degs[i], directed=True)
- Is there any option I could active that would help me in those cases I
described above?
- Is there a better way how to create representative small networks?
Any help on that issue will be much appreciated.
Best wishes,
Jana
--
Sent from: http://main-discussion-list-for-the-graph-tool-project.982480.n3.nabble.com/

I am curious what is being used to calculate the standard deviation of the
average in gt.vertex_average and gt.edge_average
>>> t2=gt.Graph()
>>> t2.add_vertex(2)
>>> t2.add_edge(t2.vertex(0), t2.vertex(1))
>>> gt.vertex_average(t2, "in")
(0.5, 0.35355339059327373)
Now, shouldn't std be σ(n)=sqrt(((0-0.5)^2+(1-0.5)^2)/2)=0.5 ?
also q(n-1)=sqrt((0.5^2+0.5^2)/(2-1))~=0.70710
0.3535 is sqrt(2)/4 which happens to be σ(n-1)/2, so it seems there is some
relation to that.
A little bigger graph.
>>> t3=gt.Graph()
>>> t3.add_vertex(5)
>>> t3.add_edge(t3.vertex(0), t3.vertex(1))
>>> gt.vertex_average(t3, "in")
(0.2, 0.17888543819998318)
Now, we should have 0,1,0,0,0 series for vertex incoming degree.
So Windows calc gives σ(n)=0.4 and σ(n-1)~=0.44721, so where does 0.1788854
come from ?
Reason, I am asking because, I have a large graph, where the average looks
quite alright but the std makes no sense, as going by the histogram, degree
values are quite a bit more distributed than the std would indicate.
--
View this message in context: http://main-discussion-list-for-the-graph-tool-project.982480.n3.nabble.com…
Sent from the Main discussion list for the graph-tool project mailing list archive at Nabble.com.

Hi,
I was wondering if there is any way to assign vertex properties while
adding edges to the graph. for example using "add_edge_list" I can assign
edge properties but later I have to iterate through all vertices again to
assign their properties.
I know this is not a problem when the vertex property is of the type "int"
or "float" because then one can use "vprop.a = values", but in case of
"string" and "object" this method doesn't work
What would be the best/fastest way to handle this situation.
I guess it would be very helpful to extend the "add_edge_list" function to
accept vertex property in some way.
cheers,
--
Mohsen

I ran mcmc_equilibrate on a nested block state model in a weighted graph. As
per instructions, I copied the initially computed state in another object
with increased hierarchy depth to 10. However, this fixed the depth to 10.
Everything computed afterwards has depth 10 even if is clear that after 3 or
4 levels the nodes converge to one.
There are many empty branches and when I try to plot it with empty_branches
= False, I get an error stating it is not a tree.
RuntimeError: Invalid hierarchical tree: No path from source to target.
Did anybody perform any similar analyses?
The hierarchy after mcmc_equilibrate:
<NestedBlockState object, with base <BlockState object with 24 blocks (24
nonempty), degree-corrected, with 1 edge covariate, for graph <Graph
object, undirected, with 230 vertices and 11230 edges, edges filtered by
(<PropertyMap object with key type 'Edge' and value type 'bool', for
Graph 0x7fc3a89f1210, at 0x7fc3a64911d0>, False), vertices filtered by
(<PropertyMap object with key type 'Vertex' and value type 'bool', for Graph
0x7fc3a89f1210, at 0x7fc3a64912d0>, False) at 0x7fc3a89f1210>, at
0x7fc3a6491950>, and 10 levels of sizes [(230, 24), (24, 5), (5, 1), (1, 1),
(1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1)] at 0x7fc3a6491590>
--
Sent from: http://main-discussion-list-for-the-graph-tool-project.982480.n3.nabble.com/

Hi Tiago,
I looked at the example in the document here
https://graph-tool.skewed.de/static/doc/demos/inference/inference.html#samp…
<https://graph-tool.skewed.de/static/doc/demos/inference/inference.html#samp…>
.
As the example shows, we can obtain vertex marginals on all hierarchical
levels, i.e. a "vertex_pie_fractions" at each level for each node. However,
I want to find the node partition at each level for each node according to
the *largest* "vertex_pie_fraction". Therefore, I use the following code
# Hierarchical node partition as a list of np.array
bs = [np.array([np.argmax(list(pv[i])[j]) for j in range(len(list(pv[i])))])
for i in range(len(pv))]
where pv is exactly the one shown in the example.
I believe the above line of code is correct since I have checked the results
in several real networks with small sizes (around 200 nodes and 500 edges at
most).
But it will take a quite a long time for a large network (30k nodes with
400k edges or more). Is there any efficient way to do the above work?
Best,
Alex
--
Sent from: http://main-discussion-list-for-the-graph-tool-project.982480.n3.nabble.com/

Hi,
I am trying to perform network reconstruction using MeasuredBlockState. I
then collect the marginal edge probabilities which are stored as an
EdgePropertyMap 'eprob'. Would it be possible to explain why some
probabilities in 'eprob' are >1?
My understanding was that eprob of edge (a,b) is interpreted as the
/marginal posterior probability of edge(a,b) to exist in the inferred
network/, in which case all instances of eprob should be <=1. Would it be
possible to explain why this is not the case?
Thank you in advance.
--
Sent from: http://main-discussion-list-for-the-graph-tool-project.982480.n3.nabble.com/

Hi Tiago:
I encountered a puzzling error message while loading a graph:
Here is the trace:
Running `python "workers.py"' in directory `/home/jrp/GRAF'
Traceback (most recent call last):
File "workers.py", line 31, in <module>
gt_gml('./_GT/grf.gt')
File "workers.py", line 17, in gt_gml
show_g_f(g)
File "/home/jrp/GRAF/e_gops.py", line 152, in show_g_f
g = load_graph(g_f)
File "/usr/lib/python3/dist-packages/graph_tool/__init__.py", line 3285, in load_graph
g.load(file_name, fmt, ignore_vp, ignore_ep, ignore_gp)
File "/usr/lib/python3/dist-packages/graph_tool/__init__.py", line 2834, in load
ignore_vp, ignore_ep, ignore_gp)
AttributeError: 'Graph' object has no attribute 'read'
Exited
Process exited with status -1
This is the first time it happens.
What I don't understand is that lines 2833-2834 of __init__.py read as follows:
props = self.__graph.read_from_file("", file_name, _c_str(fmt),
ignore_vp, ignore_ep, ignore_gp)
There is no invocation of a 'read attribute'...

Hi all,
I just wanted to check what the most performance efficient way is to save
lots of small graphs. I have around 120k small graphs (<10 vertices) that
are currently being saved via pickle. However, I suspect that saving them
as a single large graph or as multiple separate .gt files might be more
performance efficient.
Thanks in advance.
M