コード例 #1
0
def read(dir, keys=[]):
	assert os.path.exists(dir)

	if len(keys)==0:
		keys = inspect(dir)

	datadict = {}	
	for key in keys:
		fname = os.path.join(dir,key+'.npy')
		if os.path.exists(fname):
			datadict[key] = np.load(fname)

	fname = os.path.join(dir,'ma_segment_graph.pickle')
	if os.path.exists(fname):
		datadict['ma_segment_graph'] = igraph.read(fname)

	fname = os.path.join(dir,'ma_segment_lidx.pickle')
	if os.path.exists(fname):
		datadict['ma_segment_lidx'] = pickle.load(open(fname, 'rb'))

	fname = os.path.join(dir, 'ma_clusters')
	if os.path.exists(fname):
		datadict['ma_clusters'] = []
		for f in glob(os.path.join(fname, '*.pickle')):
			datadict['ma_clusters'].append(igraph.read(f))

	return datadict
コード例 #2
0
def main():
    g1 = igraph.read("/Users/irene/Desktop/pfe/arguments_politique start.gml", format= "gml") 
    g2 = igraph.read("/Users/irene/Desktop/pfe/arguments_politiques_complets.gml", format = "gml")
    g3 = igraph.read("/Users/irene/Desktop/pfe/arguments_politique1.gml", format = "gml")

    
    gcomp1 = get_giant_component(g1)
    gcomp2 = igraph.Graph.induced_subgraph(g2,gcomp1.vs["name"])

    
    print graph_summary(g1)
    print graph_summary(g2)
コード例 #3
0
    def construir_red_autocorrelacion(self, conjuntos, nombre, contar_coinc,
                                      etiquetas_nodos):
        '''Construye la red de autocorrelación de un conjunto de conjuntos

        Parámetros
        Conjuntos es una lista de listas'''
        print(len(conjuntos))
        cantidad_nodos = len(conjuntos)
        red = open(nombre + ".net", 'w')
        red.write("*Vertices " + str(cantidad_nodos) + "\n")

        if etiquetas_nodos != None:
            for i, etiqueta in enumerate(etiquetas_nodos):
                red.write(str(i + 1) + ' "' + etiqueta + '"\n')

        red.write("*Edges\n")
        for i in range(cantidad_nodos - 1):
            for j in range(i + 1, cantidad_nodos):
                #print(i,j)
                coinc = contar_coinc(conjuntos[i], conjuntos[j])
                if (coinc > 0):
                    print(i, j, "  ", coinc)
                    red.write(
                        str(i + 1) + " " + str(j + 1) + " " + str(coinc) +
                        "\n")
        red.close()
        return igraph.read(nombre + ".net", format="pajek"), red.name
コード例 #4
0
def main():
    parser = argparse.ArgumentParser(description="""Run CONGO from the command line. Mostly meant as a demo -- only prints one cover.""")
    parser.add_argument('-d', '--demo', action='store_true', help="""Run a demo with the famous Zachary's Karate Club data set. Overrides all other options.""")
    parser.add_argument('-l', '--label', default='CONGA_index', nargs='?', const='label', help="""Choose which attribute of the graph to print.
                            When this option is present with no parameters, defaults to 'label'. When the option is not
                            present, defaults to the index.""")
    parser.add_argument('-n', '--num_clusters', type=int, help="""Specify the number of clusters to use.""")
    parser.add_argument('-w', '--height', default=2, type=int, help="""The lengh of the longest shortest paths that CONGO considers.""")
    parser.add_argument('file', nargs='?', help="""The path to the file in igraph readable format.""")
    args = parser.parse_args()
    if args.demo:
        run_demo()
        return
    if not args.file:
        print("CONGO.py: error: no file specified.\n")
        print(parser.parse_args('-h'.split()))
        return

    # only works for undirected
    G = ig.read(args.file).as_undirected()
    result = congo(G, args.height)
    if args.num_clusters:
        result.pretty_print_cover(args.num_clusters, label=args.label)
    else:
        result.pretty_print_cover(result.optimal_count, label=args.label)
コード例 #5
0
def main():
    with rasengan.tictoc("Loading Graph"):
        graph = igraph.read(args.graph_fn)
        graph.to_undirected(mode="collapse",
                            combine_edges=dict(weights="first"))

    with rasengan.tictoc("Creating Adjacent Node List"):
        adjacent_edge_list = graph.get_inclist()
        adjacent_node_list = graph.get_adjlist()

    # 1234 is just a random number.
    assert (adjacent_node_list[1234][0]
            in graph.es[adjacent_edge_list[1234][0]].tuple)

    total_vertices = float(len(adjacent_edge_list))
    with rasengan.tictoc("Creating Local Node Prob List"):
        edge_prob_list = []
        for idx, edges in enumerate(adjacent_edge_list):
            if idx % 1000 == 0:
                print idx / total_vertices * 100
            weights = np.array(graph.es[edges]["weight"])
            edge_prob_list.append(weights / weights.sum())

    queries = read_queries(args.query_fn)

    for qid, query in queries.iteritems():
        for start in query:
            weighted_random_walk(graph,
                                 start,
                                 adjacent_node_list,
                                 edge_prob_list,
                                 path_maxlength=args.path_maxlength,
                                 n_runs=args.n_runs)
コード例 #6
0
def svg_from_graph(topo_file="topology.graphml",
                   gfx_file="graph.svg",
                   layout="lgl",
                   width=800,
                   height=800,
                   node_size=14,
                   node_color="lightblue",
                   edge_color="grey",
                   label_key="id"):
    g = igraph.read(topo_file)
    #    g.to_undirected() # Use this if you want the graph to be undirected

    # Example of alternative layout: g.layout_reingold_tilford(root=0)

    width = int(width)
    height = int(height)
    node_size = int(node_size)
    node_colors = [node_color] * len(g.vs)
    edge_colors = [edge_color] * len(g.es)
    node_labels = [v[label_key][:] for v in g.vs]

    g.write_svg(gfx_file,
                layout=layout,
                width=width,
                height=height,
                vertex_size=node_size,
                font_size=node_size,
                labels=node_labels,
                colors=node_colors,
                edge_colors=edge_colors)
コード例 #7
0
ファイル: tools1.py プロジェクト: kasev/WordNets
def igraph_draw_traj(filname,pold,polar=True,layout=None):
    import igraph as ig
    g = ig.read(filname,format="graphml")
    pols=[]
    for i in g.vs:
        pols.append(pold[i['id']])
    # print pols
    if polar:
        rgbs = [(1-(i+1.)/2,(i+1.)/2,0) for i in pols]
    else:
        rgbs = [(1-i,i,0) for i in pols]
    # print filname
    GGG=nx.read_graphml(filname)
    g.vs["label"] = GGG.nodes()
    visual_style = {}
    visual_style["vertex_size"] = 15
    visual_style['vertex_color']=rgbs#'pink'
    visual_style['vertex_label_size']='10'
    visual_style["vertex_label"] = g.vs["label"]
    if layout==None:
        layout=g.layout("kk")
    # else:

    visual_style["layout"] = layout
    visual_style["bbox"] = (700, 700)
    visual_style["margin"] = 100
    return g,visual_style,layout
コード例 #8
0
ファイル: wwl.py プロジェクト: vishalbelsare/WWL
def compute_wl_embeddings_discrete(data_directory, h):
    graph_filenames = retrieve_graph_filenames(data_directory)

    graphs = [ig.read(filename) for filename in graph_filenames]

    wl = WeisfeilerLehman()
    label_dicts = wl.fit_transform(graphs, h)

    # Each entry in the list represents the label sequence of a single
    # graph. The label sequence contains the vertices in its rows, and
    # the individual iterations in its columns.
    #
    # Hence, (i, j) will contain the label of vertex i at iteration j.
    label_sequences = [
        np.full((len(graph.vs), h + 1), np.nan) for graph in graphs
    ]

    for iteration in sorted(label_dicts.keys()):
        for graph_index, graph in enumerate(graphs):
            labels_raw, labels_compressed = label_dicts[iteration][graph_index]

            # Store label sequence of the current iteration, i.e. *all*
            # of the compressed labels.
            label_sequences[graph_index][:, iteration] = labels_compressed

    return label_sequences
コード例 #9
0
ファイル: red.py プロジェクト: VigTech/networkAnalysis
    def construir_red_autocorrelacion(self, conjuntos, nombre, contar_coinc, etiquetas_nodos):
        '''Construye la red de autocorrelación de un conjunto de conjuntos en formato pajek y la escribe en un archivo nombre.net

        Parámetros
        conjuntos : Lista de listas de identificadores de papers
        nombre : Nombre del archivo .net
        contar_coinc: Función para contar los elementos de la intersección entre dos conjuntos cualesquiera
        etiquetas_nodos : etiqueta de cada nodo de la red que corresponde a cada lista de conjuntos.

        Retorna
        Tupla con un objeto igraph que sirve para calcular medidas de la red y el nombre de la red'''
        print(len(conjuntos))
        cantidad_nodos = len(conjuntos)
        red = open(nombre+".net", 'w')
        red.write("*Vertices "+str(cantidad_nodos)+"\n")

        if etiquetas_nodos!=None:
            for i,etiqueta in enumerate(etiquetas_nodos):
                red.write(str(i+1)+' "'+etiqueta.encode('utf-8', "ignore")+'"\n')

        red.write("*Edges\n")
        for i in range(cantidad_nodos-1):
            for j in range(i+1, cantidad_nodos):
                #print(i,j)
                coinc = contar_coinc(conjuntos[i],conjuntos[j])
                if(coinc > 0):
                    print(i,j,"  ",coinc)
                    red.write(str(i+1)+" "+str(j+1)+" "+str(coinc)+"\n")
        red.close()
        return igraph.read(nombre+".net",format="pajek"), red.name
コード例 #10
0
def clustering(filename, counter):

    G = igraph.read(filename,directed=False,format='ncol')
    
    D = G.community_multilevel()
    
    MIN_CLUSTER_SIZE = 1
    
    style = {}
    style['vertex_size'] = 10
    
    kept_clusters = 0
    clusters = []
    for i in D.subgraphs():
        if len(i.vs) > MIN_CLUSTER_SIZE:
            kept_clusters += 1
            clusters.append(i)
            
            style["layout"] = i.layout("fr", maxiter=250) # "fr" or "lgl" work nicely
    
            igraph.plot(i, 'cluster_visualization/cluster_'+str(counter)+'_'+str(kept_clusters)+'.pdf', **style)
            
    print('total clusters -->',len(D.subgraphs()))
    print('kept clusters -->',kept_clusters)
    return clusters
def main(gpath):

    G = ig.read(gpath)
    components = G.components()

    nxG = nx.read_gpickle(gpath.replace('.gml', ''))
    nodes = sorted(nxG.nodes())
    node_ix = dict(zip(nodes, range(len(nodes))))

    node_id_to_comp = np.zeros((G.vcount(), 2), dtype=int)
    Ps = []
    for i, component in enumerate(
            sorted(components, key=lambda c: len(c), reverse=True)):
        sG = G.subgraph(component)
        if sG.vcount() > 1:
            print("Component %d" % sG.vcount())

        P = sG.shortest_paths_dijkstra()
        for n in range(sG.vcount()):
            label = sG.vs[n]['label']
            node_n = node_ix[label]
            assert np.sum(node_id_to_comp[node_n, :]) == 0
            node_id_to_comp[node_n, :] = (i, n)

        Ps.append(P)

    output_path = "../generated-data/pairwise_features/%s_shortest_path_len_sparse" % (
        os.path.basename(gpath).replace('.gml', ''))

    np.savez(output_path, Ps=Ps, node_id_to_comp=node_id_to_comp)
コード例 #12
0
def main(args):
    parser = argparse.ArgumentParser()
    parser.add_argument('input', metavar='graph.pickle',
                        help='Input graph file')
    parser.add_argument(
        '--connection',
        default='postgresql://*****:*****@localhost/osrm',
        help='Postgres connection string.  Default %(default)s'
    )
    parser.add_argument('--verbose', action='store_true',
                        help='Increase logging level')

    args = parser.parse_args()

    logging.basicConfig(
        level=logging.INFO if args.verbose else logging.WARNING)

    log.info("Creating DB engine")
    engine = create_engine(args.connection, echo=False)

    log.info("Creating DB session")
    Session = sessionmaker(bind=engine)
    session = Session()

    log.info("Creating OSRM tables")
    models.Base.metadata.create_all(engine)
    session.query(models.OSRMRouteNode).delete()

    g = igraph.read(args.input)

    export_nodes(g, session)
コード例 #13
0
    def construir_red_autocorrelacion(self, conjuntos, nombre, contar_coinc, etiquetas_nodos):
        '''Construye la red de autocorrelación de un conjunto de conjuntos

        Parámetros
        Conjuntos es una lista de listas'''
        print(len(conjuntos))
        cantidad_nodos = len(conjuntos)
        red = open(nombre+".net", 'w')
        red.write("*Vertices "+str(cantidad_nodos)+"\n")

        if etiquetas_nodos!=None:
            for i,etiqueta in enumerate(etiquetas_nodos):
                red.write(str(i+1)+' "'+str(etiqueta)+'"\n')

        red.write("*Edges\n")
        for i in range(cantidad_nodos-1):
            #print i
            for j in range(i+1, cantidad_nodos):
                #print(i,j)
                coinc = contar_coinc(conjuntos[i],conjuntos[j])
                if(coinc > 0):
                    #print(i,j,"  ",coinc)
                    red.write(str(i+1)+" "+str(j+1)+" "+str(coinc)+"\n")
        red.close()
        print 'acabó la red'
        return igraph.read(nombre+".net",format="pajek"), red.name
コード例 #14
0
ファイル: conga.py プロジェクト: Lab41/circulo-abridged
def main():
    parser = argparse.ArgumentParser(description="""Run CONGA from the command line. Mostly meant as a demo -- only prints one cover.""")
    parser.add_argument('-m', '--modularity_measure', choices=['lazar'],
                   help="""Calculate the modularities using the specified
                            modularity measure. Currently only supports lazar.""")
    parser.add_argument('-n', '--num_clusters', type=int, help="""Specify the number of clusters to use.""")
    parser.add_argument('-d', '--demo', action='store_true', help="""Run a demo with the famous Zachary's Karate Club data set. Overrides all other options.""")
    parser.add_argument('-l', '--label', default='CONGA_index', nargs='?', const='label', help="""Choose which attribute of the graph to print.
                            When this option is present with no parameters, defaults to 'label'. When the option is not
                            present, defaults to the index.""")
    parser.add_argument('file', nargs='?', help="""The path to the file in igraph readable format.""")
    args = parser.parse_args()

    if args.demo:
        run_demo()
        return
    if not args.file:
        print("CONGA.py: error: no file specified.\n")
        print(parser.parse_args('-h'.split()))
        return

    # only works for undirected
    G = ig.read(args.file).as_undirected()
    result = CONGA(G, calculate_modularities=args.modularity_measure, optimal_count=args.num_clusters)
    result.pretty_print_cover(result.optimal_count, label=args.label)
コード例 #15
0
ファイル: convertTo.py プロジェクト: snowbhr06/ndgrutedb
def convert_graph(gfn, informat, save_dir, *outformats):
    """
  Convert between igraph supported formats. No conversion to MAT or NPY available.

  Positional arguments:
  ====================

  gfn - the graph file name
  informat - the input format of the graph
  save_dir - the directory where we save result to
  outformat - a list of output formats
  """
    try:
        if informat in [
                "graphml", "ncol", "edgelist", "lgl", "pajek", "graphdb"
        ]:
            g = igraph.read(gfn, None)
        elif informat == "mat":
            g = csc_to_igraph(loadAnyMat(gfn))
        elif informat == "npy":
            g = csc_to_igraph(np.load(gfn).item())
        elif informat == "attredge":
            g = attredge_to_igraph(gfn)
        else:
            err_msg = "[ERROR]: Unknown format '%s'. Please check format and retry!" % informat
            print err_msg
            return (None, err_msg)
    except Exception, err_msg:
        print err_msg
        return (None, "[ERROR]: " + str(err_msg))
コード例 #16
0
ファイル: tools.py プロジェクト: mboudour/WordNets
def igraph_draw_traj(filname, pold, polar=True, layout=None):
    import igraph as ig
    g = ig.read(filname, format="graphml")
    pols = []
    for i in g.vs:
        pols.append(pold[i['id']])
    # print pols
    if polar:
        rgbs = [(1 - (i + 1.) / 2, (i + 1.) / 2, 0) for i in pols]
    else:
        rgbs = [(1 - i, i, 0) for i in pols]
    # print filname
    GGG = nx.read_graphml(filname)
    g.vs["label"] = GGG.nodes()
    visual_style = {}
    visual_style["vertex_size"] = 15
    visual_style['vertex_color'] = rgbs  #'pink'
    visual_style['vertex_label_size'] = '10'
    visual_style["vertex_label"] = g.vs["label"]
    if layout == None:
        layout = g.layout("kk")
    # else:

    visual_style["layout"] = layout
    visual_style["bbox"] = (700, 700)
    visual_style["margin"] = 100
    return g, visual_style, layout
コード例 #17
0
def main(gpath, steps):

    G = ig.read(gpath)

    output = G.community_walktrap(steps=steps)

    if hasattr(output, 'as_clustering'):
        output = output.as_clustering()

    comms = {
        G.vs['label'][i]: "comm %d" % output.membership[i]
        for i in range(G.vcount())
    }

    print("Num communities: %d" % (len(np.unique(list(comms.values())))))

    comms_to_nodes = defaultdict(set)
    for g, c in comms.items():
        comms_to_nodes[c].add(g)

    comm_sizes = np.array([len(comms_to_nodes[c]) for c in comms_to_nodes])

    print("Median communitiy size: %0.2f" % np.median(comm_sizes))
    print("# communities with 1 node: %d" % np.sum(comm_sizes == 1))

    output_path = '../generated-data/communities/%s_%dsteps.json' % (
        os.path.basename(gpath).replace('.gml', ''), steps)

    with open(output_path, 'w') as f:
        json.dump(comms, f)
コード例 #18
0
def svg_from_graph(topo_file="topology.graphml",
                   gfx_file="graph.svg",
                   layout="lgl",
                   width=800,
                   height=800,
                   node_size=14,
                   node_color="lightblue",
                   edge_color="grey",
                   label_key="id"):
    g = igraph.read(topo_file)
#    g.to_undirected() # Use this if you want the graph to be undirected
    
    # Example of alternative layout: g.layout_reingold_tilford(root=0)
    
    width = int(width)
    height = int (height)
    node_size = int(node_size)
    node_colors = [node_color]*len(g.vs)
    edge_colors = [edge_color]*len(g.es)
    node_labels = [v[label_key][:] for v in g.vs]
    
    g.write_svg(gfx_file, layout=layout, width=width, height=height,
                vertex_size=node_size, font_size=node_size,
                labels=node_labels, colors=node_colors,
                edge_colors=edge_colors)
コード例 #19
0
ファイル: sfanalysis.py プロジェクト: kelvinfkr/SFAnalysis
def write_degree_sequences(gml_dir, deg_dir):
    gml_df = buildGMLcatalog(gml_dir)
    fpV = gml_df['fp_gml']
    analysis_df = pd.DataFrame(columns=['num_edges', 'Weighted', 'Directed',
                                         'Bipartite', 'Multigraph', 'Multiplex',
                                         'fp_gml', 'n', 'alpha', 'xmin','ntail',
                                         'Lpl', 'ppl', 'dexp', 'dln', 'dstrexp',
                                         'dplwc', 'meandeg'])
    for fp in fpV:
        g = igraph.read(fp)
        #### find what kind of graph this is (follow hierarchical ordering of types)
        # check first for multiplex
        row = gml_df[gml_df.fp_gml==fp]
        if row['Multiplex'].item() == 1:
            processmultiplex(g,fp, deg_dir, analysis_df)
        elif row['Bipartite'].item() == 1:
            processbipartite(g, fp, deg_dir,analysis_df)
        elif row['Multigraph'].item() == 1:
            processmultigraph(g, fp, deg_dir,analysis_df)
        elif row['Weighted'].item() == 1:
            processweighted(g, fp, deg_dir,analysis_df)
        elif row['Directed'].item() == 1:
            processdirected(g, fp, deg_dir,analysis_df)
        else:
            readdeg(g, fp,deg_dir,analysis_df)
    return analysis_df
コード例 #20
0
ファイル: vulnsFinder.py プロジェクト: chubbymaggie/TRACY
def CompareWithKSplit():

    refGraph = igraph.read(os.path.join(sourcesDir,sourceFunctionName))
    refGraph['name'] = sourceFunctionName

    if (os.name != "nt"):
        #p = multiprocessing.Pool(initializer=workerInit,initargs=[len(refGraph.vs)])
        p = multiprocessing.Pool()
        mapper = p.imap_unordered
        #mapper = itertools.imap
    else:
        mapper = itertools.imap
        #workerInit(len(refGraph.vs))
    
    reportFile = CounterXlsReport(csvName + "-K=" + str(myK) + "-" + sourceFunctionName) 

    print "Prepping db - (func files) - target=" +os.path.join(sourcesDir,sourceFunctionName)
    sourcesList3k = list(mapper(identity,split2k.ksplitGraphObject(myK,refGraph,True)))
    print "For k=" + str(myK) + " we have - " + str(len(sourcesList3k))
    print "end db prep"
   
    from simple_db import DBSimpleClient

    db = DBSimpleClient()
            
    params =  [doOneFunctionFileRW,itertools.izip(db.get_all(),itertools.cycle([sourcesList3k]))]
    #if (mapper !=  itertools.imap):
    #    params.append(50)       
         
    for allFields in mapper(*params):    
        for fields in allFields:           
            reportFile.writeLine(fields)
コード例 #21
0
def start_create_gml(workfolder):
    workfolder_gml = gt.createFolder(workfolder + "GML\\")
    workfolder_att = gt.createFolder(workfolder + "ATT\\")
    i = 0
    for fp in os.listdir(workfolder):
        fname = os.path.splitext(fp)
        i += 1
        if fname[-1] == '.repost':  # or fname[-1]=='.comment':
            wbfilep = workfolder + fp
            print i, wbfilep
            gmlfp = workfolder_gml + fname[0] + '.gml'
            g = ig.Graph()
            if not os.path.exists(gmlfp):
                g = weibo2g.start(wbfilep, gmlfp,
                                  addcommentlist=True)  #ig.read(gmlfp)#
            else:
                g = ig.read(gmlfp)

            "add time slice function"
            for percent in percentlist:
                lengthNow = int(round(len(timelist) * percent))
                lengthNow = lengthNow if lengthNow > 1 else 1
                timelistPercentNow = timelist[:lengthNow]
                timelistPeriodNow = selecTime(timelistPercentNow, periodcnt)
                for timep in timelistPeriodNow:
                    g = g.subgraph_edges(es.select(createdtimetos_le=timep))

            #grt.analyzeNetNodes(g,workfolder_att,str(fname[0]))
            grt.analyzeNetNodes_New(g, workfolder_att, str(fname[0]))
            print grt.analysisNet(g)
コード例 #22
0
async def query(request):
    req_file = request.files.get("file")
    file_name = req_file.name
    body = req_file.body.decode("unicode_escape")
    with open("files/" + file_name, "w+") as file:
        file.write(body)
    file_path = "files/" + file_name
    graph = ig.read(file_path, format="graphml")
    colors = {
                "#3217A7":10008,
                "#F0F007": 205005,
                "White":163001,
                "#9725A4":135007,
                "#000000": 164010,
                "#156911":189010,
                '#A71717':157000
            }
    for pos, x in enumerate(graph.vs['color']):
        graph.vs[pos]['color'] = colors[x]

    for pos, x in enumerate(graph.es['color']):
        graph.es[pos]['color'] = colors[x]

    return redirect(
        graphistry.bind(
            source='src',
            destination='dst',
            point_color='color',
            edge_color='color'
        ).plot(graph)
    )
コード例 #23
0
def main():
    graph_file_name = f'{DATA_DIR}/graph_{sys.argv[1]}.gml'

    if not os.path.isfile(graph_file_name):
        print('First argument must be name of existing file with model')
        return

    start_date = datetime.datetime.now()
    print('Reading graph...')
    g = igraph.read(graph_file_name)
    alg = sys.argv[2]
    print('Looking for community')
    if alg == 'lp':
        lp = find_communities_label_propagation(g)
        save(g, lp)
    elif alg == 'ml':
        ml = find_communities_multilevel(g)
        save(g, ml)
    elif alg == 'im':
        im = find_communities_infomap(g)
        save(g, im)
    else:
        print('Incorrect second argument. Must be one of [lp, ml, im]')
        return

    end_date = datetime.datetime.now()
    print(f'{sys.argv[1]},{alg},{(end_date - start_date).total_seconds()}')
コード例 #24
0
    def superFunctionsGenerator():
        for exeName in filter(lambda x: inWhiteList(x, 'exe'),
                              os.listdir(targetsDir)):

            print "loading - " + exeName + " ... "
            currentExeDir = os.path.join(
                targetsDir, os.path.join(exeName,
                                         functionsGraphsDirectoryName))

            for funcFileName in filter(
                    lambda x: inWhiteList(
                        os.path.splitext(x)[0], 'functionName'),
                    filter(lambda x: x.endswith(myExt),
                           os.listdir(currentExeDir))):

                print "FUNC begin - " + funcFileName + " ... "

                tarGraph = igraph.read(
                    os.path.join(currentExeDir, funcFileName))
                tarGraph['name'] = funcFileName

                #funcFileName and exe are only for the timeout print
                yield {
                    'tarGraph': tarGraph,
                    'refGraph': refGraph,
                    'sourcesList3k': sourcesList3k,
                    'funcFileName': funcFileName,
                    'exeName': exeName
                }

                print "FUNC finished " + funcFileName

            print "finished loading " + exeName
コード例 #25
0
ファイル: convertTo.py プロジェクト: hqychr/MR-connectome
def convert_graph(gfn, informat, save_dir, *outformats):
  """
  Convert between igraph supported formats. No conversion to MAT or NPY available.

  Positional arguments:
  ====================

  gfn - the graph file name
  informat - the input format of the graph
  save_dir - the directory where we save result to
  outformat - a list of output formats
  """
  try:
    if informat in ["graphml", "ncol", "edgelist", "lgl", "pajek", "graphdb"]:
      g = igraph.read(gfn, None)
    elif informat == "mat":
      g = csc_to_igraph(loadAnyMat(gfn))
    elif informat == "npy":
      g = csc_to_igraph(np.load(gfn).item())
    else:
      err_msg = "[ERROR]: Unknown format '%s'. Please check format and re-try!" % informat
      print err_msg
      return err_msg
  except Exception, err_msg:
    print err_msg
    return "[ERROR]: "+str(err_msg)
コード例 #26
0
ファイル: igraph_to_csc.py プロジェクト: hqychr/MR-connectome
def main():
  parser = argparse.ArgumentParser(description="Convert an igraph to a csc object")
  parser.add_argument("graph_fn", action="store", help="The name of the igraph to read from disk. *Must be gml format!")

  parser.add_argument("-g", "--gen_graph", action="store_true", help="Generate a new ER graph")
  parser.add_argument("-n", "--num_nodes", action="store", type=int, help="The number of nodes in the ER graph")
  parser.add_argument("-p", "--probability", action="store", type=float, help="The probability of connectivity of each node to another in the graph")
  parser.add_argument("-s", "--save", action="store_true", help="Save conversion to disk")
  parser.add_argument("-f", "--save_fn", action="store", default="csc_matlab", help="Save file name")

  parser.add_argument("-t", "--test", action="store_true", help="Run test only!")

  result = parser.parse_args()

  if result.test:
    test()
    exit(1)

  if os.path.exists(result.graph_fn):
    g = igraph.read(result.graph_fn, format="gml")

  elif result.gen_graph or result.num_nodes or result.probability:
    assert (result.gen_graph and result.num_nodes and result.probability), "You must set all ER parameters i.e. n, p"
    g = igraph.Graph.Erdos_Renyi(n=result.num_nodes, p=result.probability)
    igraph.write(g, result.save_fn+".gml", format="gml")

  else:
    sys.stderr.writelines("Invalid path %s ... and all (i.e. n, p, g) ER parameters not set so no action taken. \n EXITING NOW! \n")
    exit(-1)

  igraph_to_csc(g, result.save, result.save_fn)
コード例 #27
0
def main(timestamp):
    nng = ig.read(f'/tmp/{timestamp}_leiden_graph.gml',
                  format='graphml')
    partition = la.find_partition(nng, la.ModularityVertexPartition)
    clusters = partition.membership
    clusters = np.array(clusters).astype(str)
    np.savetxt(f'/tmp/{timestamp}_leiden_clusters.csv',
               clusters, delimiter=',', newline='\n', fmt='%s')
コード例 #28
0
def nx_to_igraph(G):
    temp_dir = tempfile.mkdtemp()
    tmpfile = os.path.join(temp_dir, 'graph.graphml')
    nx.write_graphml(G, tmpfile)
    ig = igraph.read(tmpfile, format="graphml")
    os.remove(tmpfile)
    os.rmdir(temp_dir)
    return (ig)
コード例 #29
0
def main():
  G = ig.read("enron.gml")
  test_degree_centrality_hypothesis(G)
  test_closeness_centrality_hypothesis(G)
  test_betweenness_centrality_hypothesis(G)
  test_eigenvector_centrality_hypothesis(G)
  test_pagerank_hypothesis(G)
  test_hits_authority_hypothesis(G)
コード例 #30
0
def max_bcentrality_igraph(filename):
  G = ig.read(filename)
  bcs = ig.betweenness(G)
  index, value = max(enumerate(bcs), key=operator.itemgetter(1))
  vs = ig.VertexSeq(G)
  print "node with max betweenness centrality =", vs[index]
  print "indegree of this node =", vs[index].indegree()
  print "outdegree of this node =", vs[index].outdegree()
コード例 #31
0
def max_bcentrality_igraph(filename):
  G = ig.read(filename)
  bcs = ig.betweenness(G)
  index, value = max(enumerate(bcs), key=operator.itemgetter(1))
  vs = ig.VertexSeq(G)
  print "node with max betweenness centrality =", vs[index]
  print "indegree of this node =", vs[index].indegree()
  print "outdegree of this node =", vs[index].outdegree()
コード例 #32
0
def main(graph_path, selected_features=None):

    G = nx.read_gpickle(graph_path)
    nodes = list(sorted(G.nodes()))

    nodes_to_features = collections.defaultdict(dict)
    extract_features_networkx(G, nx_features, nodes_to_features,
                              selected_features)

    iG = ig.read(graph_path + '.gml')
    extract_features_ig(iG, ig_features, nodes_to_features, selected_features)

    # features are ordered according to nodes
    F = []
    feature_labels = []
    selected_features = nx_features + ig_features if selected_features is None else selected_features
    for feature in selected_features:
        Ff = []
        for n in nodes:
            v = nodes_to_features[n]

            Ff.append(v[feature])
        Ff = np.array(Ff)

        if len(Ff.shape) == 1:
            Ff = Ff[:, None]

        if Ff.shape[1] == 1:
            feature_labels.append(feature)
        else:
            for i in range(Ff.shape[1]):
                feature_labels.append("%s_%d" % (feature, i))

        F.append(Ff)

    F = np.hstack(F)

    mu = np.mean(F, axis=0)
    std = np.std(F, axis=0)

    print(mu)
    print(std)

    # normalize
    F = stats.zscore(F, axis=0)

    print(F.shape)

    print(np.min(F, axis=0))
    print(np.max(F, axis=0))
    print(np.mean(F, axis=0))
    print(np.std(F, axis=0))

    print(feature_labels)

    output_path = '../generated-data/features/%s_topology' % (
        os.path.basename(graph_path))
    np.savez(output_path, F=F, feature_labels=feature_labels, mu=mu, std=std)
コード例 #33
0
 def __init__(self, network=None, time_serie=None, output='network.NET'):
     self.time_serie = time_serie
     if network is None:
         self.network = None
         self.N = len(self.time_serie)
     else:
         self.network = igraph.read(network, format="pajek")
         self.N = self.network.vcount()
     self.output = output
コード例 #34
0
 def load(filename):
     print("Loading "+filename)
     g = ig.read(
         filename, format="ncol",
         directed=True, names=True
     )
     g.delete_vertices([0,1])
     print("Done")
     return(g)
コード例 #35
0
def main():
    parser = argparse.ArgumentParser(
        description=
        """Run CONGA from the command line. Mostly meant as a demo -- only prints one cover."""
    )
    parser.add_argument(
        "-m",
        "--modularity_measure",
        choices=["lazar"],
        help="""Calculate the modularities using the specified
                            modularity measure. Currently only supports lazar.""",
    )
    parser.add_argument(
        "-n",
        "--num_clusters",
        type=int,
        help="""Specify the number of clusters to use.""",
    )
    parser.add_argument(
        "-d",
        "--demo",
        action="store_true",
        help=
        """Run a demo with the famous Zachary's Karate Club data set. Overrides all other options.""",
    )
    parser.add_argument(
        "-l",
        "--label",
        default="CONGA_index",
        nargs="?",
        const="label",
        help="""Choose which attribute of the graph to print.
                            When this option is present with no parameters, defaults to 'label'. When the option is not
                            present, defaults to the index.""",
    )
    parser.add_argument(
        "file",
        nargs="?",
        help="""The path to the file in igraph readable format.""")
    args = parser.parse_args()

    if args.demo:
        run_demo()
        return
    if not args.file:
        print("conga.py: error: no file specified.\n")
        print(parser.parse_args("-h".split()))
        return

    # only works for undirected
    G = ig.read(args.file).as_undirected()
    result = conga(
        G,
        calculate_modularities=args.modularity_measure,
        optimal_count=args.num_clusters,
    )
    result.pretty_print_cover(result.optimal_count, label=args.label)
コード例 #36
0
ファイル: drawwordnet.py プロジェクト: gunyarakun/nicotagmap
def main():
  g = igraph.read('tag_wordnet.lgl', 'lgl')

  # draw graph
  for v in g.vs:
    v['label'] = v['name']
  p = igraph.drawing.Plot('tag_wordnet.pdf', igraph.drawing.BoundingBox(6000, 6000))
  p.add(g)
  p.save()
コード例 #37
0
ファイル: cool_unusual.py プロジェクト: snifhex/mlia-examples
def q7():
  G = read_gdf("../../data/network_analysis/MiddleEastern.gdf")
  nx.write_gml(G, "/tmp/MiddleEastern.gml")
  G = ig.read("/tmp/MiddleEastern.gml")
  bcs = G.betweenness()
  labels = [v["label"] for v in G.vs()]
  label_bcs = sorted(zip(labels, bcs), key=operator.itemgetter(1), reverse=True)
  ingredient_set = set(["coriander", "garlic", "walnut", "dill"])
  print [x for x in label_bcs if x[0] in ingredient_set]
コード例 #38
0
    def runSimulation(self, plot=True):
        full = self.time
        if plot == True:
            self.movie = gm.GraphMovie()
#        attrs = {'fillcolor':fields ,'width':0.5,'height':0.5,'fontsize':0.0,'nodedegreesize':False, 'plotlabel':'agent0_'+str(full-ttime) }
#     A = nx.to_agraph(net);
#   1 A.layout(prog = 'twopi');
        while full > 0:
            if plot == True and self.time == full:
                self.net = igraph.read(self.string + ".gml")
                for i, v in enumerate(self.net.vs):
                    v['label'] = str(i)
                    v['color'] = self.fields[0, i]
                self.movie.addGraph(self.net)
            elif plot == True and self.time != full:
                self.net = igraph.read(self.string + ".gml")
                for i, v in enumerate(self.net.vs):
                    v['label'] = str(i)
                    if i == self.edges[sampvar[0]][0] or i == self.edges[
                            sampvar[0]][1]:
                        v['color'] = 0.0

                    else:
                        v['color'] = self.fields[0, i]
#                 e = self.net.es[int(sampvar[0])];
#                 print e;
#                 print "edges"
#                 print sampvar[0]
#                 print self.edges[sampvar[0]][0]; print self.edges[sampvar[0]][1];
#                 e['color'] = 0.0;                                   # set edge color
                self.movie.addGraph(self.net)
            sampvar = np.random.randint(0, len(self.edges), (1))
            # the edge(interaction) sampling process
            interact = float(self.fields[0, self.edges[sampvar[0]][0]] +
                             self.fields[0, self.edges[sampvar[0]][1]]) / 2
            self.fields[0, self.edges[sampvar[0]][0]] = float(
                self.fields[0, self.edges[sampvar[0]][0]] + interact) / 2
            self.fields[0, self.edges[sampvar[0]][1]] = float(
                self.fields[0, self.edges[sampvar[0]][1]] + interact) / 2
            # attrs['fillcolor'] = fields;
            full = full - 1
#            attrs['plotlabel'] = 'agent0_'+str(full-ttime);
        self.movie.doMovieLayout()
        self.movie.renderMovie(name=self.string)
コード例 #39
0
    def setGraph(self, g: Union[str, Graph]):
        if isinstance(g, str):
            g = igraph.read(g)
        self.g = wrapGraph(g)

        for mode in self.modes:
            if mode.onSetGraph():
                break
        self.resetViewRect()
        self.update()
コード例 #40
0
def simple_read_net():
    '''读取pajek格式文件'''
    g = ig.read("testdata/GR3_60.NET", format="pajek")
    # 设置边和顶点颜色
    g.vs["color"] = "#3d679d"
    g.es["color"] = "red"

    graphStyle = {"vertex_size": 12, 'margin': 6}
    graphStyle["layout"] = g.layout("fr")  #设置布局
    g.write_svg('GR3_60_graph.svg', width=600, height=600, **graphStyle)
コード例 #41
0
def main():
  g = igraph.read('tag_wordnet.lgl', 'lgl')
  for v in g.vs:
    v['label'] = v['name']
  d = g.community_fastgreedy()

  p = igraph.drawing.Plot('graphtree.pdf', igraph.drawing.BoundingBox(5000, 13000))
  # p.add(g)
  p.add(d)
  p.save()
コード例 #42
0
ファイル: utils.py プロジェクト: daniaki/ppi_wrangler
def igraph_from_tuples(v_names):
    tmp = tempfile.mktemp(suffix='.ncol', prefix='graph_', dir='tmp/')
    fp = open(tmp, "w")
    for (name_a, name_b) in v_names:
        fp.write("{} {}\n".format(name_a, name_b))
    fp.close()
    # will store node names under the 'name' vertex attribute.
    g = igraph.read(tmp, format='ncol', directed=False, names=True)
    os.remove(tmp)
    return g
コード例 #43
0
def to_igraph(graph):
    # Initialise the optimiser, using default settings
    import networkx as nx
    import igraph as ig
    g = ig.Graph()
    if anonymize:
        nx.write_graphml(anonymize(graph), "/tmp/test_graph.graphml")
    else:
        nx.write_graphml(graph, "/tmp/test_graph.graphml")
    return ig.read("/tmp/test_graph.graphml", format='graphml')
コード例 #44
0
ファイル: exporters.py プロジェクト: LoLab-VU/Magine
def nx_to_igraph(network):
    try:
        import igraph
    except ImportError:
        raise ImportError('requires igraph ')
    file_descriptor, file_path = tempfile.mkstemp(suffix='.gml')

    nx.write_gml(network, file_path)
    igraph_network = igraph.read(file_path)
    return igraph_network
コード例 #45
0
def nx_to_igraph(network):
    try:
        import igraph
    except ImportError:
        raise ImportError('requires igraph ', )
    file_descriptor, file_path = tempfile.mkstemp(suffix='.gml')

    nx.write_gml(network, file_path)
    igraph_network = igraph.read(file_path)
    return igraph_network
コード例 #46
0
def CompareWithKSplit():

    refGraph = igraph.read(os.path.join(sourcesDir,sourceFunctionName))
    refGraph['name'] = sourceFunctionName

    if (os.name != "nt"):
        #p = multiprocessing.Pool(initializer=workerInit,initargs=[len(refGraph.vs)])
        p = multiprocessing.Pool()
        mapper = p.imap_unordered
        #mapper = itertools.imap
    else:
        mapper = itertools.imap
        #workerInit(len(refGraph.vs))
    
    reportFile = CounterXlsReport(csvName + "-K=" + str(myK) + "-" + sourceFunctionName) 

    print "Prepping db - (func files) - target=" +os.path.join(sourcesDir,sourceFunctionName)
    sourcesList3k = list(mapper(identity,split2k.ksplitGraphObject(myK,refGraph,True)))
    print "For k=" + str(myK) + " we have - " + str(len(sourcesList3k))
    print "end db prep"
   
    def inWhiteList(value,atrbName):
        for whiteListEntry in filter(lambda x: x['source']==sourceName,whiteList):
            #print "CHECK " + atrbName
            if whiteListEntry[atrbName] == value:
                return True
        return False
   
    def superFunctionsGenerator():
        for exeName in filter(lambda x:inWhiteList(x,'exe'),os.listdir(targetsDir)):
            
            print "loading - " + exeName + " ... " 
            currentExeDir = os.path.join(targetsDir,os.path.join(exeName,functionsGraphsDirectoryName))

            for funcFileName in filter(lambda x:inWhiteList(os.path.splitext(x)[0],'functionName'),filter(lambda x:x.endswith(myExt),os.listdir(currentExeDir))):
                
                print "FUNC begin - " + funcFileName + " ... " 
                
                tarGraph = igraph.read(os.path.join(currentExeDir,funcFileName))
                tarGraph['name'] = funcFileName
                
                #funcFileName and exe are only for the timeout print
                yield {'tarGraph':tarGraph,'refGraph':refGraph,'sourcesList3k':sourcesList3k,'funcFileName':funcFileName,'exeName':exeName}
                
                print "FUNC finished " + funcFileName
            
            print "finished loading " + exeName 
            
    params =  [doOneFunctionFileRW,superFunctionsGenerator()]
    #if (mapper !=  itertools.imap):
    #    params.append(50)       
         
    for allFields in mapper(*params):    
        for fields in allFields:           
            reportFile.writeLine(fields)
コード例 #47
0
def make_projection(graph, atts):
    """ makes bipartite projections, returns seller projection"""

    # PREPARE EDGE ATTRIBUTES
    graph.es['val'] = list(atts['vals'])
    graph.es['hs'] = list(atts['hs'])
    graph.es['dest'] = list(atts['dest'])
    graph.es['hss'] = list(atts['hss'])
    graph.es['dest_source'] = list(atts['dest_source'])
    graph.es['imp_name'] = list(atts['imp_name'])

    # PREPARE VERTEX ATTRIBUTES
    # The strength member function sums all of the edge values
    graph.vs['val'] = graph.strength(graph.vs, weights='val')
    # Get list of exporters who sell to the US
    us_list = what_sellers(graph.es, 'USA')
    graph.vs['US'] = 0
    graph.vs[us_list]['US'] = 1
    # Get list of exporters who sell to a seleted foreign coutnry
    us_list = what_sellers(graph.es, 'VEN')
    graph.vs['VEN'] = 0
    graph.vs[us_list]['VEN'] = 1
    # Get most frequent hs by exporter
    hs_tup = source_hs(graph.es,'hss')
    graph.vs['hs_source'] = 0
    graph.vs[hs_tup[0]]['hs_source'] = hs_tup[1]
    # Get most frequent destimation
    dest_tup = source_hs(graph.es,'dest_source')
    graph.vs['dest_source'] = 0
    graph.vs[dest_tup[0]]['dest_source'] = dest_tup[1]
    
    # SIZES FROM graph.csv
    size = 10046
    edge_size = 58031
    big_size = 40789 
    sub = size

    # MAKE THE TWO TYPES (SELLER AND BUYER)
    graph.vs['type'] = [1] * big_size
    graph.vs[sub:]['type'] = [0] * (big_size - sub)

    # PROEJECT AND ADD ATTRIBUTES
    proj2, proj1 = graph.bipartite_projection()
    proj1.vs['val'] = graph.vs[0:sub]['val']
    proj1.vs['val'] = graph.vs[0:sub]['val']
    # Get most valuable importer 
    max_imp = pd.read_pickle('max_imp.pickle')
    proj1.vs['imp_name'] = max_imp

    # WRITE AND READ
    proj1.write_pickle('proj1.pickle')
    proj1 = ig.read('proj1.pickle')
    print(ig.summary(proj1))

    return proj1, proj2
コード例 #48
0
def load_dat():
    graph = ig.read('igraph_small.csv',format='edge')
    vals = pd.read_csv('vals_small.csv')['val']
    hs = pd.read_csv('vals_small.csv')['hs10']
    hss = pd.read_csv('vals_small.csv')['hs_source']
    dest = pd.read_csv('vals_small.csv')['dest_alf']
    dest_source = pd.read_csv('vals_small.csv')['dest']
    imp_name = pd.read_csv('vals_small.csv')['imp_name']
    atts = {'vals': vals,'hs': hs,'dest': dest,
            'hss': hss,'dest_source': dest_source,
            'imp_name': imp_name}
    return graph, atts
コード例 #49
0
ファイル: main.py プロジェクト: kansuke231/Network-Comparison
def main(filepath,feature):
    pwd = os.getcwd() # This should be your home directory (e.g. /Users/blahblah).
    filename = os.path.split(filepath)[1]
    f = open(pwd + "/%s/"%feature + filename + ".%s.txt"%feature,"w")
    writer = csv.writer(f)
    G = igraph.read(filepath)
    G.simplify()
    G.to_undirected()
    largest_c = G.clusters(mode="STRONG").giant()
    exec("f_value = %s(largest_c)"%feature)
    writer.writerow((filepath,f_value))
    f.close()
コード例 #50
0
    def _read_celltype_graph(self, 
                             connmatrix_file, 
                             format='gml', 
                             cellcount_file=None):
        celltype_graph = None
        cellcount_dict = {}
        if cellcount_file is not None:
            with open(cellcount_file, 'r') as popfile:
                reader = csv.reader(popfile)
                for line in reader:
                    if len(line) > 0:
                        cellcount_dict[line[0]] = int(line[1])

        if format == 'csv':
            celltype_graph = igraph.Graph(len(cellcount_dict), directed=True)
            index = 0
            for celltype, cellcount in cellcount_dict.items():
                celltype_graph.vs[index]['label'] = celltype 
                celltype_graph.vs[index]['count'] = cellcount
                index += 1
            reader = csv.reader(file(connmatrix_file))
            header = reader.next()
            row = 0
            for line in reader:
                if len(line) <= 0:
                    continue
                pre = header[row]
                source = celltype_graph.vs.select(label_eq=pre)
                if len(source) > 0:
                    source = source[0]
                row += 1
                col = 0
                for entry in line:
                    post = header[col]
                    target = celltype_graph.vs.select(label_eq=post)
                    if len(target) > 0:
                        target = target[0]
                    value = int(entry)
                    celltype_graph.add_edges((source.index, target.index))                    
                    eid = celltype_graph.get_eid(source.index, target.index)
                    celltype_graph.es[eid]['weight'] = value
                    col += 1
        elif format == 'gml':
            celltype_graph = igraph.read(f=connmatrix_file, format=format)

        celltype_graph['doc'] = 'Celltype-based connectivity data. \
count of node *n* is the number of cells of type *n* \
that are present in the model. weight of edge (a, b) \
is the number of cells of type *a* that connect to \
each cell of type *b*.'

        return celltype_graph
コード例 #51
0
ファイル: util.py プロジェクト: rohangoel96/IRCLogParser
def HACK_convert_nx_igraph(nx_graph):
    """ 
        There exist no current method to convert a nx graph to an igraph.
        So this is a hack which does sp.
        Args:
            nx_graph: input nx_graph to be converted to igraph
        Returns:
            ig_graph: converted igraph
    """
    nx.write_pajek(nx_graph, "/tmp/rohan.net")
    ig_graph = igraph.Graph()
    ig_graph = igraph.read("/tmp/rohan.net", format="pajek")
    return ig_graph
コード例 #52
0
ファイル: findClonesCONS.py プロジェクト: chubbymaggie/TRACY
    def superFunctionsGenerator():
        for exeName in os.listdir(targetsDir):
            print "loading - " + exeName + " ... " ,
            currentExeDir = os.path.join(targetsDir,os.path.join(exeName,functionsGraphsDirectoryName))

            for funcFileName in filter(lambda x:x.endswith(myExt),os.listdir(currentExeDir)):
                tarGraph = igraph.read(os.path.join(currentExeDir,funcFileName))
                tarGraph['name'] = funcFileName
                
                #funcFileName and exe are only for the timeout print
                yield {'tarGraph':tarGraph,'refGraph':refGraph,'sourcesList3k':sourcesList3k,'funcFileName':funcFileName,'exeName':exeName}
            
            print "finished loading " + exeName 
コード例 #53
0
ファイル: wordcatcut.py プロジェクト: gunyarakun/nicotagmap
def main(infile):
  g = igraph.read(infile, 'lgl')
  d = g.community_fastgreedy()
  mem = d.cut(CUT)
  categories = [[] for i in xrange(CUT)]
  r = re.compile(r'(?P<name>.+)\((?P<count>\d+)\)')
  for i, cat_no in enumerate(mem):
    m = r.match(g.vs[i]['name'])
    categories[cat_no].append((int(m.group('count')), m.group('name')))
  for i, cat in enumerate(categories):
    print '** category %d **' % i
    cat.sort(lambda x, y: -cmp(x, y))
    for c in cat:
      print "%s : %d" % (c[1], c[0])
コード例 #54
0
ファイル: load.py プロジェクト: nukui-s/sscomdetection
def load_gml(path, attr_name="value"):
    g = igraph.read(path)
    elist = g.get_edgelist()
    min_id = min(chain.from_iterable(elist))
    if min_id == 1:
        offset = True
    else:
        offset = False
    if offset:
        elist = [(i-1, j-1) for i, j in elist]
    try:
        labels = [int(v) for v in g.vs.get_attribute_values(attr_name)]
    except:
        labels = [v for v in g.vs.get_attribute_values(attr_name)]
    return elist, labels
コード例 #55
0
ファイル: plotN.py プロジェクト: imih/information-propagation
def plotDegDistr(gml_file):
  g = read(gml_file)
  print g.summary()

  xs, ys = zip(*[(left, count) for left, _, count
    in g.degree_distribution().bins()])
  _sum = sum(ys)
  _novy = [float(ys[i]) / _sum for i in range(0, len(ys))]

  plt.stem(xs, _novy)
  plt.yscale("log")
  plt.xscale("log")
  plt.ylabel('p(k)')
  plt.xlabel('k')
  plt.show()
コード例 #56
0
ファイル: lgl2xgmml.py プロジェクト: gunyarakun/nicotagmap
def main(infile, outfile):
  g = igraph.read(infile, 'lgl')

  # write XGMML
  root = etree.XML('<?xml version="1.0" encoding="UTF-8" standalone="yes"?><graph label="Network" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:cy="http://www.cytoscape.org" xmlns="http://www.cs.rpi.edu/XGMML"  directed="0" />')
  for v in g.vs:
    etree.SubElement(root, 'node', label = v['name'].decode('utf-8'),
                                   id = str(v.index))
  for e in g.es:
    etree.SubElement(root, 'edge', source = str(e.source),
                                   target = str(e.target),
                                   label = '')
  file = open(outfile, 'w')
  file.write(etree.tostring(root, encoding = 'utf-8',
                                  pretty_print = True))
  file.close()
コード例 #57
0
ファイル: dblp_io.py プロジェクト: wdan/territories
    def read_graph_paper(self, graph_str):
        try:
            graph_file = open(self.path+graph_str+'.txt')
        except IOError:
            print 'The file '+self.path+graph_str+'.txt'+' does not exist!'
            return None

        g = ig.read(self.path+graph_str+'.net')
        for r in graph_file:
            lines = r.split('\t')
            id = int(lines[0])
            cluster = str(lines[1])
            label = str(lines[2]).rstrip('\n')
            g.vs[id]['class'] = cluster
            g.vs[id]['label'] = label
        graph_file.close()
        return g