epochs = args.niters
    length = args.nsteps

    if args.testDataType == 'sbm_cd':
        node_num = 200
        community_num = 2
        node_change_num = args.nodemigration
        dynamic_sbm_series = dynamic_SBM_graph.get_community_diminish_series_v2(node_num,
                                                                                community_num,
                                                                                length,
                                                                                1,
                                                                                node_change_num)
        graphs = [g[0] for g in dynamic_sbm_series]

        datafile = dataprep_util.prep_input_dynTriad(graphs, length, args.testDataType)

        embedding = dynamicTriad(niters=args.niters,
                                 starttime=args.starttime,
                                 datafile=datafile,
                                 batchsize=args.batchsize,
                                 nsteps=args.nsteps,
                                 embdim=args.embdim,
                                 stepsize=args.stepsize,
                                 stepstride=args.stepstride,
                                 outdir=args.outdir,
                                 cachefn=args.cachefn,
                                 lr=args.lr,
                                 beta=args.beta,
                                 negdup=args.negdup,
                                 datasetmod=args.datasetmod,
Exemple #2
0
                              './intermediate/dec_weights_dynAERNN.hdf5'],
            savefilesuffix = "testing")

embs = []
t1 = time()
for temp_var in range(lookback+1, length+1):
                emb, _ = embedding.learn_embeddings(graphs[:temp_var])
                embs.append(emb)
print (embedding._method_name+':\n\tTraining time: %f' % (time() - t1))
plt.figure()
plt.clf()    
plot_dynamic_sbm_embedding.plot_dynamic_sbm_embedding_v2(embs[-5:-1], dynamic_sbm_series[-5:])    
plt.show()

#dynamicTriad
datafile  = dataprep_util.prep_input_dynTriad(graphs, length, testDataType)
embedding= dynamicTriad(niters     = 20,
                 starttime  = 0,
                 datafile   = datafile,
                 batchsize  = 1000,
                 nsteps     = length,
                 embdim     = dim_emb,
                 stepsize   = 1,
                 stepstride = 1,
                 outdir     = outdir,
                 cachefn    = '/tmp/'+ testDataType,
                 lr         = 0.1,
                 beta       = [0.1,0.1],
                 negdup     = 1,
                 datasetmod = 'core.dataset.adjlist',
                 trainmod   = 'dynamicgem.dynamictriad.core.algorithm.dynamic_triad',
def plot_dynam_graph(title, graph_list):
    #dynAERNN
    graphs = []
    for graph in graph_list:
        if not graph == None:
            graphs.append(graph)
    dynamic_sbm_series = graphs
    outdir = os.path.exists(os.path.dirname(__file__)+"/out")
    testDataType = 'sbm_cd'
    length = len(graph_list)
    dim_emb  = 128
    lookback = 2
    embedding = DynAERNN(d   = dim_emb,
                beta           = 5,
                n_prev_graphs  = lookback,
                nu1            = 1e-6,
                nu2            = 1e-6,
                n_aeunits      = [500, 300],
                n_lstmunits    = [500,dim_emb],
                rho            = 0.3,
                n_iter         = 250,
                xeta           = 1e-3,
                n_batch        = 100,
                modelfile      = None, #['./intermediate/enc_model_dynAERNN.json', 
                                #'./intermediate/dec_model_dynAERNN.json'],
                weightfile     = None, #['./intermediate/enc_weights_dynAERNN.hdf5', 
                                #'./intermediate/dec_weights_dynAERNN.hdf5'],
                savefilesuffix = None) #"testing")

    embs = []
    t1 = time()
    for temp_var in range(lookback+1, length+1):
                    emb, _ = embedding.learn_embeddings(graphs[:temp_var])
                    embs.append(emb)
    print (embedding._method_name+':\n\tTraining time: %f' % (time() - t1))
    plt.figure()
    plt.clf()    
    plot_dynamic_sbm_embedding.plot_dynamic_sbm_embedding_v2(embs[-5:-1], dynamic_sbm_series[-5:])    
    plt.show()

    # #dynamicTriad
    datafile  = dataprep_util.prep_input_dynTriad(graphs, length, testDataType)
    embedding= dynamicTriad(niters     = 20,
                    starttime  = 0,
                    datafile   = datafile,
                    batchsize  = 1000,
                    nsteps     = length,
                    embdim     = dim_emb,
                    stepsize   = 1,
                    stepstride = 1,
                    outdir     = outdir,
                    cachefn    = '/tmp/'+ testDataType,
                    lr         = 0.1,
                    beta       = [0.1,0.1],
                    negdup     = 1,
                    datasetmod = 'core.dataset.adjlist',
                    trainmod   = 'dynamicgem.dynamictriad.core.algorithm.dynamic_triad',
                    pretrain_size = length,
                    sampling_args = {},
                    validation = 'link_reconstruction',
                    datatype   = testDataType,
                    scale      = 1,
                    classifier = 'lr',
                    debug      = False,
                    test       = 'link_predict',
                    repeat     = 1,
                    resultdir  = outdir,
                    testDataType = testDataType,
                    clname       = 'lr')
                    #node_num     = node_num )
    t1 = time()
    embedding.learn_embedding()
    print (embedding._method_name+':\n\tTraining time: %f' % (time() - t1))
    embedding.get_embedding()
    embedding.plotresults(dynamic_sbm_series)