예제 #1
0
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 19 10:26:13 2019

@author: Jerry
"""

from GRN import DynamicModel, Recoder, MonteCarloSimulator

N = 2000
alpha = 0.003
avgDegree = 3
temperature = 0.00
totalSteps = 50
binDist = 20
numSim = 20
dm = DynamicModel(temperature, N, avgDegree, alpha)
re = Recoder(dm, totalSteps, binDist, False)
simulator = MonteCarloSimulator(dm, totalSteps, numSim)
matShape = (simulator.numSim, re.dynModel.P)

simulator.simulation()

compute_observable_matrix = Recoder.observable_matrix(
    re, simulator, matShape, True)(Recoder.hamming_overlap)
print("computing observable matrix...")
compute_observable_matrix()
print("Done. Now drawing...")
re.draw_distance_matrix()
예제 #2
0
totalSteps = 50
binDist = 100
numSim = 100
regimes_P = ['saturated', 'sub_extensive', 'limited']
regimes_C = ['sparse', 'extreme_dilution', 'dense']
figFile = r'E:\KCL\FinalProject\figures\withoutExt\trials_0\alpha_1_C_3/'

config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.gpu_options.allocator_type = 'BFC'
config.gpu_options.per_process_gpu_memory_fraction = 0.95

dm = DynamicModel(temperature,
                  N,
                  avgDegree,
                  alpha,
                  tfConfig=config,
                  gamma=gamma,
                  withExt=True)
re = Recoder(dm, totalSteps, binDist, False)
simulator = MonteCarloSimulator(dm, totalSteps, numSim)
matShape = (simulator.numSim, simulator.numSim)
compute_q_matrix = Recoder.observable_matrix(re, simulator,
                                             matShape)(Recoder.EA_overlap)

for reg_p in regimes_P:
    for reg_c in regimes_C:
        if reg_p is not 'limited':
            dm.regime_P(reg_p)
        else:
            dm.regime_P(reg_p, limitedRegimePatNum)
예제 #3
0
    itNum = 20  #total time steps to run
    #deciding which regime we're now in
    reg_p = 'limited'
    reg_c = 'sparse'
    #recording configuration we got
    cfg = {
        'delta': delta,
        'gamma': gamma,
        'alpha': alpha,
        'T': T,
        'dims': dims,
        'avgDegree': avgDegree,
        'numSim': numSim,
        'itNum': itNum,
        'reg_p': reg_p,
        'reg_c': reg_c
    }

    dm = DynamicModel(T,
                      dims,
                      avgDegree,
                      alpha,
                      gamma=gamma,
                      delta=delta,
                      tfConfig=config)
    dm.regime_P(reg_p, patNumFiniteReg)
    dm.regime_C(reg_c)
    dm.generate()

    dm.save(fname)
alpha = 0.25
avgDegree = 3
temperature = 0.00
totalSteps = 120
binDist = 20
numSim = 70

config = tf.ConfigProto()
config.gpu_options.allow_growth=True
config.gpu_options.allocator_type = 'BFC'
config.gpu_options.per_process_gpu_memory_fraction = 0.95

dm = DynamicModel(temperature,
                  N,
                  avgDegree,
                  alpha,
                  ifDeco=False,
                  tfConfig=config,
                  withExt=False)
recorder = Recoder(dm,
                   totalSteps,
                   binDist)
simulator = MonteCarloSimulator(dm,
                                totalSteps,
                                numSim)
matShape = (totalSteps, dm.P)
compute_observable_matrix = Recoder.observable_matrix(recorder,
                                                      simulator,
                                                      matShape,
                                                      True)(Recoder.hamming_overlap)
예제 #5
0
        'delta': delta,
        'gamma': gamma,
        'alpha': alpha,
        'T': T,
        'dims': dims,
        'avgDegree': avgDegree,
        'numSim': numSim,
        'itNum': itNum,
        'reg_p': reg_p,
        'reg_c': reg_c
    }

    dm = DynamicModel(T,
                      dims,
                      avgDegree,
                      alpha,
                      gamma=gamma,
                      delta=delta,
                      tfConfig=config)
    dm.regime_P(reg_p, patNumFiniteReg)
    dm.regime_C(reg_c)
    dm.load(fname)

    initState = dm.pat['ita'][0, :].T.reshape((dm.N, 1))
    #    initState = np.zeros((dm.N,1),dtype=np.float32)
    #    for i in range(8):
    #        initState[i,0] = 1.0

    obs = Observable(dm)
    obs.Quant.Traj_m = np.zeros((dm.P, itNum), dtype=np.float32)
    obs.Quant.Traj_a = np.zeros((1, itNum), dtype=np.float32)