Python networkx 模块，read_gpickle() 实例源码

def load_models(self):
        now = datetime.now()
        self.rec_candidates = []

        if self.last_model_update is None or (now - self.last_model_update).days >= 1:
            print('loading model', now)
            model_path = '{0}/it-topics'.format(settings.PORTRAIT_FOLDER)
            lda_filename = os.readlink('{0}/current_lda_model.gensim'.format(model_path))

            self.lda_model = gensim.models.ldamulticore.LdaMulticore.load(lda_filename)
            self.topic_graph = nx.read_gpickle('{0}/current_topic_graph.nx'.format(model_path))

            with gzip.open('{0}/current_candidates.json.gz'.format(model_path), 'rt') as f:
                self.rec_candidates = json.load(f)
                print('loaded', len(self.rec_candidates), 'candidates')

            self.last_model_update = datetime.now()

def graph2png(infile, outdir, fname=None):
    '''
    infile: input .gpickle or .graphml file
    outdir: path to directory to store output png files
    '''
    # if file is .gpickle, otherwise load .graphml
    try:
        graph = nx.read_gpickle(infile)
    except:
        graph = nx.read_graphml(infile)
    # get numpy array equivalent of adjacency matrix
    g = nx.adj_matrix(graph).todense()
    fig = plt.figure(figsize=(7, 7))
    # plot adjacency matrix
    p = plt.imshow(g, interpolation='None', cmap='jet')
    if fname is None:
        fname = os.path.split(infile)[1].split('.')[0] + '.png'
    save_location = outdir + fname
    plt.savefig(save_location, format='png')
    print(fname + ' done!')

def loadGraphs(filenames, verb=False):
    """
    Given a list of files, returns a dictionary of graphs

    Required parameters:
        filenames:
            - List of filenames for graphs
    Optional parameters:
        verb:
            - Toggles verbose output statements
    """
    #  Initializes empty dictionary
    if type(filenames) is not list:
        filenames = [filenames]
    gstruct = OrderedDict()
    for idx, files in enumerate(filenames):
        if verb:
            print("Loading: " + files)
        #  Adds graphs to dictionary with key being filename
        fname = os.path.basename(files)
        try:
            gstruct[fname] = nx.read_graphml(files)
        except:
            gstruct[fname] = nx.read_gpickle(files)
    return gstruct

def load_saved_pickle(cls, graph_path):
        """Loads a graph saved as pickle

        Parameters
        ----------
        graph_path: The path of the graph that should be loaded

        Returns
        -------
        NxGraph: Graph object

        Examples
        --------
        >>> g.load_saved_pickle("graph.bz2")
        """
        return cls(graph_obj=nx.read_gpickle(graph_path))

def call_exps(params, data_set):
    print('Dataset: %s' % data_set)
    model_hyp = json.load(
        open('gem/experiments/config/%s.conf' % data_set, 'r')
    )
    if bool(params["node_labels"]):
        node_labels = cPickle.load(
            open('gem/data/%s/node_labels.pickle' % data_set, 'rb')
        )
    else:
        node_labels = None
    di_graph = nx.read_gpickle('gem/data/%s/graph.gpickle' % data_set)
    for d, meth in itertools.product(params["dimensions"], params["methods"]):
        dim = int(d)
        MethClass = getattr(
            importlib.import_module("gem.embedding.%s" % meth),
            methClassMap[meth]
        )
        hyp = {"d": dim}
        hyp.update(model_hyp[meth])
        MethObj = MethClass(hyp)
        run_exps(MethObj, di_graph, data_set, node_labels, params)

def from_pickle(path, check_version=True):
    """Reads a graph from a gpickle file.

    :param file or str path: File or filename to read. Filenames ending in .gz or .bz2 will be uncompressed.
    :param bool check_version: Checks if the graph was produced by this version of PyBEL
    :return: A BEL graph
    :rtype: BELGraph
    """
    graph = read_gpickle(path)

    raise_for_not_bel(graph)
    if check_version:
        raise_for_old_graph(graph)

    return graph

def read_graph(self, infile):
        self.graph = nx.read_gpickle(infile)

def compare_graph_outputs(generated_output, stored_output_file_name):
    expected_output = nx.read_gpickle(expected_output_directory+stored_output_file_name)
    if(nx.is_isomorphic(generated_output, expected_output)):
        return True
    return False

def loadSBMGraph(file_prefix):
    graph_file = file_prefix + '_graph.gpickle'
    G = nx.read_gpickle(graph_file)
    node_file = file_prefix + '_node.pkl'
    with open(node_file, 'rb') as fp:
        node_community = pickle.load(fp)
    return (G, node_community)

def loadRealGraphSeries(file_prefix, startId, endId):
    graphs = []
    for file_id in range(startId, endId + 1):
        graph_file = file_prefix + str(file_id) + '_graph.gpickle'
        graphs.append(nx.read_gpickle(graph_file))
    return graphs

def loadDynamicSBmGraph(file_perfix, length):
    graph_files = ['%s_%d_graph.gpickle' % (file_perfix, i) for i in xrange(length)]
    info_files = ['%s_%d_node.pkl' % (file_perfix, i) for i in xrange(length)]

    graphs = [nx.read_gpickle(graph_file) for graph_file in graph_files]

    nodes_comunities = []
    perturbations = []
    for info_file in info_files:
        with open(info_file, 'rb') as fp:
            node_infos = pickle.load(fp)
            nodes_comunities.append(node_infos['community'])
            perturbations.append(node_infos['perturbation'])

    return zip(graphs, nodes_comunities, perturbations)

def cache_read(self, cache_folder):
        self.contentProvider = pickle.load(
            open(cache_folder + '/contentProvider.cache', 'rb')
        )
        self.contentNodes = pickle.load(
            open(cache_folder + '/contentNodes.cache', 'rb')
        )
        self.accessNodes = pickle.load(
            open(cache_folder + '/accessNodes.cache', 'rb')
        )
        self.netGraph = nx.read_gpickle(cache_folder + '/asGraph.cache')
        self.as2ip = pickle.load(
            open(cache_folder + '/as2ip.cache', 'rb')
        )
        return None

def load_verb_res():    
    ''' Load verb semantics related resources. '''
    global G, w2v_model, w2v_model_gf
    sys.stderr.write('Loading graph...')
    G=nx.read_gpickle('../../sdewac_graph/verbs_and_args_no_subcat.gpickle') 
    sys.stderr.write(' done.\nLoading word2vec models...')
    w2v_model_gf=gensim.models.Word2Vec.load('../../word2vec/vectors_sdewac_gf_skipgram_min50_new.gensim')    
    sys.stderr.write(' done.\n')