How to use community_leiden?

[duhwang-official]

I am trying to use IGraphs.jl for community detection.
Follwoing is my test code, but does not work. Could you fix this problem?

using Graphs, IGraphs

g=smallgraph(:karate)

ig=IGraph(g)

ig_membership = IGVectorInt()
ig_degree = IGVectorInt()
ig_weights = IGVectorFloat()
ig_nb_clusters = 0
ig_quality=0.0

LibIGraph.vector_int_init(membership, LibIGraph.vcount(ig))
LibIGraph.community_leiden(ig, Nothing, Nothing, 0.05, 0.01, 0, 1, membership   )

[Krastanov]

I will be maybe a bit redundant in my answer, but my goal is to "document" some assumptions and style decisions this wrapper has made that are not necessarily yet very well documented in the README.

1. First, I am looking up the function you are interested in the official C documentation. It has the following signature:

igraph_error_t igraph_community_leiden(const igraph_t *graph,
                            const igraph_vector_t *edge_weights, const igraph_vector_t *node_weights,
                            const igraph_real_t resolution_parameter, const igraph_real_t beta, const igraph_bool_t start,
                            const igraph_integer_t n_iterations,
                            igraph_vector_int_t *membership, igraph_integer_t *nb_clusters, igraph_real_t *quality);

As can be seen in the documentation, this function has a lot of optional arguments that can be set to null. This wrapper does translate all of the low-level C functions that use pointers and return codes (i.e. any function with a name LibIGraph.igraph_FNAME) into more idomatic julia functions (with names LibIGraph.FNAME), but that translation currently does not support these optional arguments. I do plan to add that capability in the future.

2. So we either need to provide the optional arguments, or we need to hack together something that passes a null to the lower level functions, or we need to directly use the lower level functions.

2.a. providing the optional arguments

using Graphs, IGraphs
g=smallgraph(:karate)
ig=IGraph(g)

membership = IGVectorInt(zeros(nv(ig)))
edge_weights = IGVectorFloat(ones(ne(ig)))
node_weights = IGVectorFloat(ones(nv(ig)))

LibIGraph.community_leiden(ig, edge_weights, node_weights, 0.05, 0.01, 0, 1, membership   )

output: (2, 0.6865384615384615) (and the membership vector has been modified)

2.b. making a new argument type that looks enough like a null. If you are interested, please feel free to submit this IGNull as a PR to this library -- other people would probably also benefit from this.

julia> struct IGNull
           objref
           function IGNull()
               return new(C_NULL)
           end
       end

julia> LibIGraph.community_leiden(ig, IGNull(), IGNull(), 0.05, 0.01, 0, 1, membership   )
(2, 0.6858974358974359)

2.c Using directly the lower level API.

... that is actually more convoluted than necessary, given that 2.b exists, so I will not be trying to make up an example with it unless there is specific interest.

[duhwang-official]

I appreciate your insightful reply.

[duhwang-official]

I have quick question. Big apology for disturbing your valuable time.

In fact I am trying to apply that method to weighted graph, whose edge weights are not uniform.
Following is example what I want to try. But the question comes to me is about indexing.
Should I use 0 based index for IGVectorFloat or 1 based index?
I read the previous discussion, but still confusing.

using Graphs, SimpleWeightedGraphs, IGraphs

g = smallgraph(:karate)
ig = IGraph(g)
wg = SimpleWeightedGraph(g)
[add_edge!(wg, src(e), dst(e), rand()) for e in edges(g)]

membership = IGVectorInt(zeros(LibIGraph.vcount(ig)))
nodeweight = IGVectorFloat(ones(LibIGraph.vcount(ig)))
edgeweight = IGVectorFloat(ones(LibIGraph.ecount(ig)))

for (ind,e) in enumerate(edges(wg))
    edgeweight[ind] = get_weight(wg,e)
    #= or
    edgeweight[ind-1] = get_weight(wg,e)
    =#
end

LibIGraph.community_leiden(ig, edgeweight, nodeweight, 0.05, 0.01,0,1, membership)

The question confusing me when I do following experiment.

vec1 = IGVectorFloat(zeros(5))
vec1[0] = -1.0
LibIGraph.vector_min(vec1)

Above code to get minimum component of vector gave me 0.0 instead of -1.

I will be maybe a bit redundant in my answer, but my goal is to "document" some assumptions and style decisions this wrapper has made that are not necessarily yet very well documented in the README.

1. First, I am looking up the function you are interested in the official C documentation. It has the following signature:

igraph_error_t igraph_community_leiden(const igraph_t *graph,
                            const igraph_vector_t *edge_weights, const igraph_vector_t *node_weights,
                            const igraph_real_t resolution_parameter, const igraph_real_t beta, const igraph_bool_t start,
                            const igraph_integer_t n_iterations,
                            igraph_vector_int_t *membership, igraph_integer_t *nb_clusters, igraph_real_t *quality);

As can be seen in the documentation, this function has a lot of optional arguments that can be set to null. This wrapper does translate all of the low-level C functions that use pointers and return codes (i.e. any function with a name LibIGraph.igraph_FNAME) into more idomatic julia functions (with names LibIGraph.FNAME), but that translation currently does not support these optional arguments. I do plan to add that capability in the future.

2. So we either need to provide the optional arguments, or we need to hack together something that passes a null to the lower level functions, or we need to directly use the lower level functions.

2.a. providing the optional arguments

using Graphs, IGraphs
g=smallgraph(:karate)
ig=IGraph(g)

membership = IGVectorInt(zeros(nv(ig)))
edge_weights = IGVectorFloat(ones(ne(ig)))
node_weights = IGVectorFloat(ones(nv(ig)))

LibIGraph.community_leiden(ig, edge_weights, node_weights, 0.05, 0.01, 0, 1, membership   )

output: (2, 0.6865384615384615) (and the membership vector has been modified)

2.b. making a new argument type that looks enough like a null. If you are interested, please feel free to submit this IGNull as a PR to this library -- other people would probably also benefit from this.

julia> struct IGNull
           objref
           function IGNull()
               return new(C_NULL)
           end
       end

julia> LibIGraph.community_leiden(ig, IGNull(), IGNull(), 0.05, 0.01, 0, 1, membership   )
(2, 0.6858974358974359)

2.c Using directly the lower level API.

... that is actually more convoluted than necessary, given that 2.b exists, so I will not be trying to make up an example with it unless there is specific interest.

[Krastanov]

Apologies for the delayed response, I did not see this.

Given that this is a fairly low-level wrapper, indexing is indeed a bit messy. One day this might be fixed by providing a public Julian API, but for all the private stuff in LibIGraph, accounting for indexing changes will remain messy. For me this has not been a problem because I only use the low level wrapper in internal code and everything public facing is using fully Julian indexing.

The basic answer is that you should index the julia objects from 1, but if some numbers are then used internally by igraph, those should start at zero. I want to stress that this is known to be a bad way to do this, but it is necessary for the internal low-level wrapper. If you are interested, I would be happy to help you design a higher-level wrapper that does not have these annoyances.

Anyway, the code you experimented with should just raise an error (I have not bothered adding index checks, again because this is just an internal wrapper). The [0] index is invalid and this assignment probably mangled some unrelated memory. I did get a segfault when I tried it:

julia> vec1 = IGVectorFloat(zeros(5))
5-element IGVectorFloat:
 0.0
 0.0
 0.0
 0.0
 0.0

julia> vec1[0] = -1.0
malloc(): invalid next size (unsorted)

[4046086] signal 6 (-6): Aborted
in expression starting at none:0

Here is the working version:

julia> vec1[1] = -1.0
-1.0

julia> minimum(vec1)
-1.0

julia> LibIGraph.vector_min(vec1)
-1.0

Just a reminder, enumerate indexes from 1 and normal julia functions should work on your IGraph wrapped vectors, no need to use LibIGraph for those.

As I mentioned, if you would like to contribute improvements to this wrapper to make it more convenient for you to use, happy to help with those.