Exemplos de memory_capacity em Python

Exemplo n.º 1

Arquivo: emcetau.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def rvsigma(xval, lineval):
	WI = generate_input_matrix(lineval, q)
	W = generate_matrix_from_sigma(xval, q)
	#make_sparse(W, lineval)
	
	mc = memory_capacity(W, WI, memory_max=150, iterations=1200, iterations_coef_measure=1000, use_input=False, target_later=True)
	return mc

Exemplo n.º 2

Arquivo: mvsrs.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def compute():
	global values

	if not os.path.isdir(savedir):
		print("dir {} does not exist, creating".format(savedir))
		os.mkdir(savedir)

	total_values = get_total_values()
	total_lengths = [len(total_values[si]) for si, _ in enumerate(xticks)]

	start = time()
	t = time()

	values = [list() for _ in xticks]
	try:
		for it in itertools.count():
			for si, sigma in enumerate(xticks):
				W = generate_matrix_from_sigma(sigma) #generate_matrix_from_sigma(sigma)
				WI = generate_input_matrix(tau)

				mc = memory_capacity(W, WI, memory_max=150, iterations=1200, iterations_coef_measure=1000, use_input=False, target_later=True)
				values[si].append(mc)
			print("counted to", it)
			if time() > t + 10:
				xtickstds = np.zeros(len(xticks))
				for si, sigma in enumerate(xticks):
					xtickstds[si] = np.std(values[si]) / np.sqrt(len(values[si]) + total_lengths[si])
				print("max standard error of MC sample average:", np.max(xtickstds))
				t = time()
	except KeyboardInterrupt:
		save_values(values)

	print("total:", round(time() - start), 'seconds')

Exemplo n.º 3

def measure_mc(W, WI):
    return memory_capacity(W,
                           WI,
                           memory_max=150,
                           iterations=1200,
                           iterations_coef_measure=1000,
                           use_input=False,
                           target_later=True)

Exemplo n.º 4

def measure_mc(W, WI):
    return memory_capacity(W, WI,
                           memory_max=int(1.1*WI.shape[0]),
                           iterations=1200,
                           iterations_coef_measure=1000,
                           use_input=False,
                           target_later=True,
                           calc_lyapunov=False)

Exemplo n.º 5

Arquivo: mcbai.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def measure(**kwargs):
	mcs = np.zeros(matrices)
	for it in range(matrices):
		WI = np.random.uniform(-tau, tau, q)
		W = np.random.normal(0, sigma, [q, q])
		mc = memory_capacity(W, WI, memory_max=2*q, iterations=it_pinv, iterations_coef_measure=it_cc, **kwargs)
		mcs[it] = mc
	return mcs

Exemplo n.º 6

Arquivo: orthogonal.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def measure_mc(W, WI, calc_lyapunov):
    return memory_capacity(W,
                           WI,
                           memory_max=memory_max,
                           iterations=1200,
                           iterations_coef_measure=1000,
                           use_input=False,
                           target_later=True,
                           calc_lyapunov=calc_lyapunov)

Exemplo n.º 7

Arquivo: emcetau.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def rvsmax(xval, lineval):
	WI = generate_input_matrix(lineval, q)
	W = generate_matrix_from_sigma(1, q)
	#make_sparse(W, lineval)
	#W = W * (xval / np.linalg.svd(W, compute_uv=0)[0])
	W = normalize_smax(W, xval)
	
	mc = memory_capacity(W, WI, memory_max=150, iterations=1200, iterations_coef_measure=1000, use_input=False, target_later=True)
	return mc

Exemplo n.º 8

Arquivo: emcetau.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def rvrho(xval, lineval):
	WI = generate_input_matrix(lineval, q)
	W = generate_matrix_from_sigma(1, q)
	#make_sparse(W, lineval)
	#if np.max(np.abs(np.linalg.eig(W)[0])) == 0:
#		ipdb.set_trace()
	
	W = normalize_rho(W, xval)
	
	mc = memory_capacity(W, WI, memory_max=150, iterations=1200, iterations_coef_measure=1000, use_input=False, target_later=True)
	return mc

Exemplo n.º 9

Arquivo: genetic.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def measure_mc(W):
    # print(W[0])
    W = np.array(W[0]).reshape((100, 100))
    return memory_capacity(W,
                           WI,
                           memory_max=memory_max,
                           iterations=1200,
                           iterations_coef_measure=1000,
                           use_input=False,
                           target_later=True,
                           calc_lyapunov=False)

Exemplo n.º 10

Arquivo: emceresi.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def rvgen(xval, lineval, Wgen):
    WI = generate_input_matrix(tau, lineval)
    W = Wgen(xval, lineval)

    mc = memory_capacity(W,
                         WI,
                         memory_max=int(lineval * 3 / 2),
                         iterations=1200,
                         iterations_coef_measure=1000,
                         use_input=False,
                         target_later=True)
    return mc

Exemplo n.º 11

def rvsigma(xval, lineval):
    WI = generate_input_matrix(tau, q)
    W = generate_matrix_from_sigma(xval, q)
    make_sparse(W, lineval)

    mc = memory_capacity(W,
                         WI,
                         memory_max=150,
                         iterations=1200,
                         iterations_coef_measure=1000,
                         use_input=False,
                         target_later=True)
    return mc

Exemplo n.º 12

def rvsmax(xval, lineval):
    WI = generate_input_matrix(tau, q)
    W = generate_matrix_from_sigma(1, q)
    make_sparse(W, lineval)
    #W = W * (xval / np.linalg.svd(W, compute_uv=0)[0])
    W = normalize_smax(W, xval)

    mc = memory_capacity(W,
                         WI,
                         memory_max=150,
                         iterations=1200,
                         iterations_coef_measure=1000,
                         use_input=False,
                         target_later=True)
    return mc

Exemplo n.º 13

def rvrho(xval, lineval):
    WI = generate_input_matrix(tau, q)
    W = generate_matrix_from_sigma(1, q)
    make_sparse(W, lineval)
    #if np.max(np.abs(np.linalg.eig(W)[0])) == 0:
    #		ipdb.set_trace()

    W = normalize_rho(W, xval)

    mc = memory_capacity(W,
                         WI,
                         memory_max=150,
                         iterations=1200,
                         iterations_coef_measure=1000,
                         use_input=False,
                         target_later=True)
    return mc

Exemplo n.º 14

Arquivo: mvsrs.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def compute():
    global values

    if not os.path.isdir(savedir):
        print("dir {} does not exist, creating".format(savedir))
        os.mkdir(savedir)

    total_values = get_total_values()
    total_lengths = [len(total_values[si]) for si, _ in enumerate(xticks)]

    start = time()
    t = time()

    values = [list() for _ in xticks]
    try:
        for it in itertools.count():
            for si, sigma in enumerate(xticks):
                W = generate_matrix_from_sigma(
                    sigma)  #generate_matrix_from_sigma(sigma)
                WI = generate_input_matrix(tau)

                mc = memory_capacity(W,
                                     WI,
                                     memory_max=150,
                                     iterations=1200,
                                     iterations_coef_measure=1000,
                                     use_input=False,
                                     target_later=True)
                values[si].append(mc)
            print("counted to", it)
            if time() > t + 10:
                xtickstds = np.zeros(len(xticks))
                for si, sigma in enumerate(xticks):
                    xtickstds[si] = np.std(values[si]) / np.sqrt(
                        len(values[si]) + total_lengths[si])
                print("max standard error of MC sample average:",
                      np.max(xtickstds))
                t = time()
    except KeyboardInterrupt:
        save_values(values)

    print("total:", round(time() - start), 'seconds')

Exemplo n.º 15

from library.mc6 import memory_capacity
import numpy as np

q = 100
sigma = 0.1
tau = 0.1

W = np.random.normal(0, sigma, [q, q])
WI = np.random.uniform(-tau, tau, q)

for i in range(10):
    mc = memory_capacity(W, WI)

Exemplo n.º 16

Arquivo: orthogonal.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def measure_mc(W, WI, calc_lyapunov):
    return memory_capacity(W, WI, memory_max=memory_max, iterations=1200,
                           iterations_coef_measure=1000, use_input=False,
                           target_later=True, calc_lyapunov=calc_lyapunov)

Exemplo n.º 17

Arquivo: emceresi.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def rvgen(xval, lineval, Wgen):
	WI = generate_input_matrix(tau, lineval)
	W = Wgen(xval, lineval)
	
	mc = memory_capacity(W, WI, memory_max=int(lineval*3/2), iterations=1200, iterations_coef_measure=1000, use_input=False, target_later=True)
	return mc

Exemplo n.º 18

Arquivo: og.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

eta = 3 * 10**-2
N = 500


def measure_mc(W, WI):
    return memory_capacity(W,
                           WI,
                           memory_max=int(1.1 * WI.shape[0]),
                           iterations=1200,
                           iterations_coef_measure=1000,
                           use_input=False,
                           target_later=True,
                           calc_lyapunov=False)


mc = np.zeros([len(rhos), len(taus)])
for rho_idx, rho in enumerate(rhos):
    for tau_idx, tau in enumerate(taus):
        W = random.normal(0, 1, [N, N])
        W = W * (rho / np.max(np.abs(np.linalg.eig(W)[0])))
        WI = random.uniform(-tau, tau, N)

        mcs = np.zeros(ORTHOPROCESS_ITERATIONS)
        for mc_idx in range(ORTHOPROCESS_ITERATIONS):
            W = learn_orthogonal(W, eta)
            mcs[mc_idx], _ = memory_capacity(W, WI)
        print('rho={}, tau={}, mc={}'.format(rho, tau, max(mcs)))
        mc[rho_idx, tau_idx] = max(mcs)

np.save('mc', mc)

Exemplo n.º 19

Arquivo: emceorto.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def measure_mc(W, WI):
    return memory_capacity(W, WI, memory_max=150, iterations=1000,
                           iterations_coef_measure=1000,
                           use_input=False, target_later=True,
                           )

Exemplo n.º 20

Arquivo: genetic.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

def measure_mc(W):
    # print(W[0])
    W = np.array(W[0]).reshape((100, 100))
    return memory_capacity(W, WI, memory_max=memory_max, iterations=1200,
                           iterations_coef_measure=1000, use_input=False,
                           target_later=True, calc_lyapunov=False)

Exemplo n.º 21

Arquivo: perftest.py Projeto: pe-ge/Computational-analysis-of-memory-capacity-in-echo-state-networks

from library.mc6 import memory_capacity
import numpy as np

q = 100
sigma = 0.1
tau = 0.1

W = np.random.normal(0, sigma, [q, q])
WI = np.random.uniform(-tau, tau, q)


for i in range(10):
	mc = memory_capacity(W, WI)