def __init__(self,
num_inputs,
num_outputs,
activation_fn="tanh",
initial_wt_max=0.01,
weights=None,
bias=None):
self.activation_fn = activation_fn
self.num_outputs = num_outputs
self.num_inputs = num_inputs
if weights is None:
weights = get_array(
matlib.rand((num_outputs, num_inputs)) * 2 *
initial_wt_max) - initial_wt_max
if bias is None:
if self.activation_fn == "relu":
# enforce positive
bias = np.ones((num_outputs, 1)) * initial_wt_max
else:
bias = get_array(
matlib.rand((num_outputs, 1)) * 2 *
initial_wt_max) - initial_wt_max
self.initial_wt_max = initial_wt_max
self.weights = weights
self.bias = bias
#Force creation of best weights\bias
self.save_state()
assert self.num_inputs == self.weights.shape[1]
assert self.num_outputs == self.weights.shape[0]
assert self.num_outputs == self.bias.shape[0]
def __init__(self, num_inputs, num_outputs, activation_fn="tanh", initial_wt_max=0.01, weights=None, bias=None):
self.activation_fn = activation_fn
self.num_outputs = num_outputs
self.num_inputs = num_inputs
if weights is None:
weights = get_array(matlib.rand((num_outputs, num_inputs)) * 2 * initial_wt_max) - initial_wt_max
if bias is None:
if self.activation_fn == "relu":
# enforce positive
bias = np.ones((num_outputs, 1)) * initial_wt_max
else:
bias = get_array(matlib.rand((num_outputs, 1)) * 2 * initial_wt_max) - initial_wt_max
self.initial_wt_max = initial_wt_max
self.weights = weights
self.bias = bias
#Force creation of best weights\bias
self.save_state()
assert self.num_inputs == self.weights.shape[1]
assert self.num_outputs == self.weights.shape[0]
assert self.num_outputs == self.bias.shape[0]
def test_random_matrix():
n = 2
k = 10
A = -matlib.rand(n, n)
x0 = 1e3 * matlib.rand(n).T
a = matlib.zeros(n).T
T = 1e-2
for i in range(n):
A[i, i] *= k
print("A\n", A)
x = compute_x_T(A, a, x0, T)
print('x(0)= ', x0.T)
print('x= ', x.T)
# compute approximate x
x_a = matlib.zeros(n).T
for i in range(n):
Ai = A[i:i + 1, i:i + 1]
x_a[i, 0] = expm(T * Ai) * x0[i, 0]
print('approximate x=', x_a.T)
a = A * x0
for i in range(n):
Ai = A[i:i + 1, i:i + 1]
ai = a[i, 0] - Ai * x0[i, 0]
xi = compute_x_T(Ai, ai, x0[i, 0], T)
x_a[i, 0] = xi[0, 0]
print('approximate x=', x_a.T)
def alternating_min(T=1000):
B = np.matrix(rand(n, r))
C = np.matrix(rand(r, n))
eta_C = 0.0001
eta_B = 0.0001
err = []
for t in range(T):
B -= eta_B * grad_B(B, C)
C -= eta_C * grad_C(B, C)
err.append(loss(B, C))
return B, C, err
def __init__(self, num_inputs, num_hidden, learning_rate = 0.1,
activation_fns = ("relu", "tanh"),
initial_wt_max = 0.01, weight_decay = 0.0, desired_sparsity = 0.05, sparsity_wt = 0.00,
w1_b1 = None, w2_b2 = None):
'''
num_inputs = number of inputs \ outputs
num_hidden = size of the hidden layer
activation_fn = activation function to use ("sigmoid" | "tanh" | "linear" | "relu")
initial_wt_max = the initial weights will be set to random weights in the range -initial_wt_max to +initial_wt_max
weight_decay = a regularization term to stop over-fitting. Only turn on if network converges too fast or overfits the data
w1_b1 are a tuple of weight matrix 1 and bias 1
w2_b2 are a tuple of weight matrix 2 and bias 2
This allows weight sharing between networks
'''
""" Properties """
self.learning_rate = learning_rate
self.activation_fns = activation_fns
self.num_inputs = num_inputs
self.num_hidden = num_hidden
""" An auto-encoder """
num_outputs = num_inputs
self.num_outputs = num_outputs
self.initial_wt_max = initial_wt_max
self.weight_decay = weight_decay
self.desired_sparsity = desired_sparsity
self.sparsity_wt = sparsity_wt
""" END Properties """
if w1_b1 == None:
self.w1 = matlib.rand((num_hidden, num_inputs)) * initial_wt_max
self.b1 = matlib.rand((1,num_hidden)) * initial_wt_max
else:
self.w1 = w1_b1[0]
self.b1 = w1_b1[1]
assert self.w1.shape == (num_hidden, num_inputs)
assert self.b1.shape == (1, num_hidden)
if w2_b2 == None:
self.w2 = matlib.rand((num_outputs, num_hidden)) * initial_wt_max
self.b2 = matlib.rand((1, num_outputs)) * initial_wt_max
else:
self.w2 = w2_b2[0]
self.b2 = w2_b2[1]
assert self.w2.shape == (num_outputs, num_hidden)
assert self.b2.shape == (1, num_outputs)
pass
def __init__(self, hidden_layer_neurons, alpha, max_error, max_epoch_amount, _lambda=1):
self.alpha = alpha
self._lambda = _lambda
self.maxError = max_error
self.maxEpochAmount = max_epoch_amount
self.hiddenLayerNeurons = hidden_layer_neurons
self.outputLayerNeurons = 4
self.hiddenLayerWeights = m.rand(hidden_layer_neurons, 24)
self.outputLayerWeights = m.rand(self.outputLayerNeurons, hidden_layer_neurons)
self.trainingSet = trainingSet.trainingSet
self.answerSet = trainingSet.answerSet
self.hiddenLayerBias = m.rand(self.hiddenLayerNeurons, 1)
self.outputLayerBias = m.rand(self.outputLayerNeurons, 1)
def __init__(self, inpDim, hidDim):
self.inpDim = inpDim #number of input neurons (and output neurons)
self.hidDim = hidDim #number of hidden neurons
self.inp = zeros((self.inpDim, 1)) #vector holding current input
self.out = zeros((self.hidDim, 1)) #output neurons
self.g = zeros((self.hidDim, 1)) #neural activity before non-linearity
self.h = zeros((self.hidDim, 1)) #hidden neuron activation
self.a = ones((self.hidDim, 1)) #slopes of activation functions
self.b = -3 * ones((self.hidDim, 1)) #biases of activation functions
scale = 0.025
self.W = scale * (
2 * rand((self.inpDim, self.hidDim)) - 0.5 * ones(
(self.inpDim, self.hidDim))
) + scale #shared network weights, i.e. used to compute hidden layer activations and estimated outputs
print self.W.shape
self.lrateRO = 0.01
#learning rate for synaptic plasticity of read-out layer (RO)
self.regRO = 0.0002
#numerical regularization constant
self.decayP = 0
#decay factor for positive weights [0..1]
self.decayN = 1
#decay factor for negative weights [0..1]
self.lrateIP = 0.001
#learning rate for intrinsic plasticity (IP)
self.meanIP = 0.2
def test_kfilter_nonstationary():
T, model = setup_nonstationary()
U = [mb.rand(2, 1) for t in range(T)]
Xo, Y = model.simulate(U)
X, P, K, XPred, PPred = model.kfilter(Y, U)
for (x, xo, p) in zip(X, Xo, P):
assert within_dist(x, p, xo)
def evaluate_em(dimR, base, eVal, X, ax2):
threshold = 1e-4;
N = X.shape[0];
K = X.shape[1];
xMean = np.mean(X, axis=1).reshape(3,1); #mean
W = ml.rand(N, dimR); # covariance
Z = W.T.dot(X-xMean); #recon
sigma_2 = sum(sum(np.power((W.dot(Z) - X), 2)).T) / (N*dimR); #variance
sigma_2 = sigma_2[0,0];
M = W.T.dot(W) + sigma_2*np.ones([dimR, dimR]);
iteration = 1;
oldProbX = 1;
flag = True;
while flag:
#E-step
EZ = np.linalg.inv(M).dot(W.T.dot(X - xMean)); #expectation of latent variable
EZZ = sigma_2*np.linalg.inv(M) + EZ.dot(EZ.T);
#M-step
W = N* (X-xMean).dot(EZ.T).dot(N*np.linalg.inv(EZZ));
sigma_2 = (np.power(np.linalg.norm(X-xMean),2) + np.trace(EZZ.T.dot(W.T.dot(W))) +\
2*(sum(sum(EZ.T.dot(W.T.dot(X-xMean))).T))) / (N * dimR);
sigma_2= sigma_2[0,0];
iteration += 1;
invM = np.linalg.inv(M);
probX = N*K + K*(N*np.log(sigma_2) + np.trace(invM) \
- np.log(np.linalg.det(invM))) + np.trace( EZ.T.dot(EZ));
err = abs(1- probX/oldProbX);
oldProbX = probX;
if (iteration > 8 and err < threshold):
flag = False;
# transformation matrix to principal space
Cov = W.dot(W.T) + sigma_2*np.ones([W.shape[0], W.shape[0]]);
[base1, eVal, order] = compute_eig(Cov, dimR);
#[base1, eVal, order] = compute_eig(np.cov(W.T.dot(X-xMean)), dimR);
eVec = base1[:, :dimR];
W = base1.dot(W);
Z = W.T.dot(X-xMean);
#projecting train data
projX = base1[:,0:dimR].T.dot(X);
xMean = np.mean(X, axis=1).reshape(3,1);
tmp = xMean *np.ones(X.shape[1]*3).reshape(3,X.shape[1]);
bias = base1[:,dimR:].T.dot(tmp);
projX = base1[:,0:dimR].dot(projX) + base1[:,dimR:].dot(bias); #projected data.
#visualize projected Data
#ax2.plot(projX[0,:], projX[1,:], projX[2,:], 'o');# label='data projected into principal space');
ax2.plot(projX[0,:Z.shape[1]/2], projX[1,:Z.shape[1]/2], projX[2,:Z.shape[1]/2], 'ro');# label='data projected into principal space');
ax2.plot(projX[0,Z.shape[1]/2:], projX[1,Z.shape[1]/2:], projX[2,Z.shape[1]/2:], 'bo');# label='data projected into principal space');
print "The number of EM steps iterated: " + str(iteration);
return [base1, Z]
def generate_testdata(self):
""" lets try to generate plista like campaign data in the form of a dictionary
input_vector =
{ 'browser' : 'firefox',
'os' : 'linux',
'publisher' : 'ksta' }
output_vector = { campaign : 'kia'
"""
input_vector = { 'browser' : 'firefox', 'os' : 'linux', 'publisher' : 'ksta' }
possible_browsers = [ 'firefox', 'ie', 'opera', 'mobile']
possible_os = [ 'windows', 'linux', 'iOS' ]
possible_publishers = ['ksta' , 'spiegel', 'golem', 'heise']
vector_set = [possible_browsers, possible_os, possible_publishers]
random_vector = []
for i in range(5):
vector = []
for x in vector_set:
additive = 0.0
index = int(round( ( rand(1)+additive ) * ( len(x)-1 ), 0))
vector.append( x[index] )
random_vector.append(vector)
print '\n'
print random_vector
def init_architecture(self, s):
self.L = 1 + self.n_h + 1 # Total number of layers
# len(s) == 0 is true when we did not define a hidden layer architecture explicitly
self.s = []
if (len(s) == 0):
'''Calculate number of neurons in each layer (using own heuristic)'''
self.s = [0] * self.L # Will hold number of neurons (including hidden) in each layer
for l in range(0, self.L):
if (l == 0):
self.s[l] = int(self.n_i + 1) # Inputs plus 1 bias
if (l > 0 and l < self.L - 1):
'''Grow number of hidden neurons logarithmically after 10'''
if (self.n_i <= 10):
self.s[l] = int(self.n_i + 1)
else:
self.s[l] = int(math.floor(10 * math.log10(self.n_i)) + 1)
if (l == self.L - 1):
self.s[l] = int(self.n_o + 1) # Adding bias to output layer (for convenience)
else:
self.s.append(int(self.n_i + 1)) # Inputs plus 1 bias
self.s.extend(s) # Add the defined hidden layer architecture (1 neuron per layer will be treated as bias)
self.s.append(int(self.n_o + 1)) # Adding bias to output layer (for convenience)
'''Initialize all neuron weights randomly between -1 and 1'''
self.Thetas = [] # Will hold L-1 matrices
for l in range(0, self.L - 1):
'''Neuron activations vector in layer l is shaped (s[l], 1)'''
'''Number of unbiased neurons in next layer is s[l+1]-1'''
shape = (self.s[l + 1] - 1, self.s[l]) # Note: we do not compute the activation for the bias neuron in next layer
Theta = np.ones(shape) - 2 * mp.rand(shape) # Matrix of 1s minus twice the matrix of random weights between 0 and 1
self.Thetas.append(Theta)
'''Examples'''
'''
def test_kfilter_nonstationary():
T, model = setup_nonstationary()
U = [mb.rand(2, 1) for t in range(T)]
Xo, Y = model.simulate(U)
X, P, K, XPred, PPred = model.kfilter(Y, U)
for (x, xo, p) in zip(X, Xo, P):
assert within_dist(x, p, xo)
def __init__(self, nbrOfCars, dx_dy, intial_point, start_points,destination_dot_radius_ratio ):
self.nbrOfCars = nbrOfCars
self.dx_dy = dx_dy
self.intial_point = intial_point
self.start_points = start_points
self.start_headings = numpy.array((180 * rand(1, self.nbrOfCars) - 90) * math.pi / 180).reshape(-1,).tolist()[0]
self.start_steerAngles = [0] # is it a bunch of zeros ?????????????????????????????
self.destination_dot_radius_ratio = destination_dot_radius_ratio
def get_random_from_matrix() -> numpy.flatiter:
"""
Construct matrix of 25 by 25 random numbers
and return its diagonal as an array
:rtype: numpy.flatiter
"""
mat = rand((25, 25))
return mat.diagonal().flat
def test_kfilter():
model = setup()
T = 100
U = [mb.rand(2, 1) for t in range(T)]
Xo, Y = model.simulate(U)
X, P, K, XPred, PPred = model.kfilter(Y, U)
for (x, xo, p) in zip(X, Xo, P):
assert within_dist(x, p, xo)
def test_rtssmoother():
model = setup()
T = 100
U = [mb.rand(2, 1) for t in range(T)]
Xo, Y = model.simulate(U)
X, P, K, M = model.rtssmooth(Y, U)
for (x, xo, p) in zip(X, Xo, P):
assert within_dist(x, p, xo)
def __init__(self, trainingSet, outputFile):
self.trainingSet_ = trainingSet
self.outputFile_ = outputFile
# initialize weights
self.weights1_ = matlib.rand(self.HIDDEN, self.FEATURES)
self.weights1_ = self.weights1_ / matlib.sqrt(self.FEATURES)
self.weights2_ = matlib.rand(self.FEATURES, self.HIDDEN)
self.weights2_ = self.weights2_ / matlib.sqrt(self.HIDDEN)
# initialize bias
self.bias1_ = matlib.zeros((self.HIDDEN, ))
self.bias2_ = matlib.zeros((self.FEATURES, ))
# initialize rho estimate vector
self.rho_est_ = matlib.zeros((self.HIDDEN, )).T
def test_kfilter():
model = setup()
T = 100
U = [mb.rand(2, 1) for t in range(T)]
Xo, Y = model.simulate(U)
X, P, K, XPred, PPred = model.kfilter(Y, U)
for (x, xo, p) in zip(X, Xo, P):
assert within_dist(x, p, xo)
def test_rtssmoother():
model = setup()
T = 100
U = [mb.rand(2, 1) for t in range(T)]
Xo, Y = model.simulate(U)
X, P, K, M = model.rtssmooth(Y, U)
for (x, xo, p) in zip(X, Xo, P):
assert within_dist(x, p, xo)
def init_subpopulations(self):
# Main excitatory subpopulation
self.e_size=int(self.params.network_group_size*.8)
self.group_e=self.subgroup(self.e_size)
self.group_e.C=self.pyr_params.C
self.group_e.gL=self.pyr_params.gL
self.group_e._refractory_time=self.pyr_params.refractory
# Main inhibitory subpopulation
self.i_size=int(self.params.network_group_size*.2)
self.group_i=self.subgroup(self.i_size)
self.group_i.C=self.inh_params.C
self.group_i.gL=self.inh_params.gL
self.group_i._refractory_time=self.inh_params.refractory
# Input-specific sub-subpopulations
self.groups_e=[]
for i in range(self.params.num_groups):
subgroup_e=self.group_e.subgroup(int(self.params.f*self.e_size))
self.groups_e.append(subgroup_e)
self.ns_e=self.group_e.subgroup(self.e_size-(self.params.num_groups*int(self.params.f*self.e_size)))
# Initialize state variables
self.vm = self.params.EL+randn(self.params.network_group_size)*mV
self.group_e.g_ampa_b = rand(self.e_size)*self.pyr_params.w_ampa_ext_correct*2.0
self.group_e.g_nmda = rand(self.e_size)*self.pyr_params.w_nmda*2.0
self.group_e.g_gaba_a = rand(self.e_size)*self.pyr_params.w_gaba*2.0
self.group_i.g_ampa_r = rand(self.i_size)*self.inh_params.w_ampa_rec*2.0
self.group_i.g_ampa_b = rand(self.i_size)*self.inh_params.w_ampa_bak*2.0
self.group_i.g_nmda = rand(self.i_size)*self.inh_params.w_nmda*2.0
self.group_i.g_gaba_a = rand(self.i_size)*self.inh_params.w_gaba*2.0
def __init_learner(self, outputFile):
self.outputFile_ = outputFile
# initialize weights
self.weights1_ = matlib.rand(self.HIDDEN, self.FEATURES)
self.weights1_ = self.weights1_ / matlib.sqrt(self.FEATURES)
self.weights2_ = matlib.rand(self.FEATURES, self.HIDDEN)
self.weights2_ = self.weights2_ / matlib.sqrt(self.HIDDEN)
# initialize bias
self.bias1_ = matlib.zeros((self.HIDDEN,))
self.bias2_ = matlib.zeros((self.FEATURES,))
# initialize rho estimate vector
self.rho_est_ = matlib.zeros((self.HIDDEN,)).T
self.errors = []
def __init_learner(self, outputFile):
self.outputFile_ = outputFile
# initialize weights
self.weights1_ = matlib.rand(self.HIDDEN, self.FEATURES)
self.weights1_ = self.weights1_ / matlib.sqrt(self.FEATURES)
self.weights2_ = matlib.rand(self.FEATURES, self.HIDDEN)
self.weights2_ = self.weights2_ / matlib.sqrt(self.HIDDEN)
# initialize bias
self.bias1_ = matlib.zeros((self.HIDDEN, ))
self.bias2_ = matlib.zeros((self.FEATURES, ))
# initialize rho estimate vector
self.rho_est_ = matlib.zeros((self.HIDDEN, )).T
self.errors = []
def getMfeature(self):
mata = npmatrix.empty((3, 4)) # random data
mata = npmatrix.zeros((3, 4)) # zeros
mata = npmatrix.ones((3, 4)) # one
mata = npmatrix.eye(3) # one along diagonal
mata = npmatrix.eye(3, 5) # one along diagonal
mata = npmatrix.identity(3) # identity square matrix
mata = npmatrix.rand(3, 7) # rand data
mata = npmatrix.ones((3, 1)) # one
print(mata)
print(mata.shape)
print(mata.dtype)
def mate(p, q, cross=0.6):
# Performs genetic algorithm mating on two polynomials
# Favors p's chromosome if cross is large, agostic iff cross == 0.5
# p, q :: (len q == len p) => [Float]
# cross :: (0 < cross < 1) => Float
assert len(p) == len(q)
assert (0 < cross) & (cross < 1)
babysChromosomes = np.array(matlib.rand(len(p)) < cross)
babysChromosomes = np.ndarray.flatten(babysChromosomes)
assert babysChromosomes.dtype == 'bool'
baby = np.zeros(len(p))
baby[babysChromosomes] = p[babysChromosomes]
baby[np.invert(babysChromosomes)] = q[np.invert(babysChromosomes)]
return baby
def testNormalizedCorrelationHorzShift2D_SameArray_AllAlgorithms(self):
nrow = 251
ncol = 250
maxLag = 3
nloop = 4
x1 = rand(ncol, nrow)
x2 = deepcopy(x1)
t1a = timeit.time.clock()
for loop in xrange(0, nloop):
arrayA = normalizedCorrelationHorzShift2D(x1, x2, maxLag, Algorithm.BRUTE_FORCE)
t2a = timeit.time.clock()
t1b = timeit.time.clock()
for loop in xrange(0, nloop):
arrayB = normalizedCorrelationHorzShift2D(x1, x2, maxLag, Algorithm.INNER_1D)
t2b = timeit.time.clock()
t1c = timeit.time.clock()
for loop in xrange(0, nloop):
arrayC = normalizedCorrelationHorzShift2D(x1, x2, maxLag, Algorithm.INNER_2D)
t2c = timeit.time.clock()
timeA = (t2a - t1a)
timeB = (t2b - t1b)
timeC = (t2c - t1c)
print("\ntestSame_NormalizedCorrelationHorzShift2D")
print(" Algorithm.BRUTE_FORCE -- time; %.6f sec -- ratio; %12.6f" % (timeA, (timeA / timeA)))
print(" Algorithm.INNER_1D -- time; %.6f sec -- ratio; %12.6f" % (timeB, (timeA / timeB)))
print(" Algorithm.INNER_2D -- time; %.6f sec -- ratio; %12.6f" % (timeC, (timeA / timeC)))
print
for shift in range(-maxLag, maxLag+1):
print("shift,A,B,C; %+3d %+12.6f %+12.6f %+12.6f" % (shift, arrayA[shift + maxLag], arrayB[shift + maxLag], arrayC[shift + maxLag]))
assert arrayA[maxLag] == 1
assert arrayB[maxLag] == 1
assert arrayC[maxLag] == 1
arrayA = list(arrayA)
arrayB = list(arrayB)
arrayC = list(arrayC)
maxIndexA = arrayA.index(max(arrayA)) - maxLag
maxIndexB = arrayB.index(max(arrayB)) - maxLag
maxIndexC = arrayC.index(max(arrayC)) - maxLag
print
print("Index of maximum A,B,C", maxIndexA, maxIndexB, maxIndexC)
print("Correlation at maximum A,B,C",
arrayA[maxIndexA + maxLag], arrayB[maxIndexB + maxLag], arrayC[maxIndexC + maxLag])
def trust_region_bfgs(T=1000, delta_hat=1, delta_0=0.1, eta=0.00001):
xk = np.matrix(rand(2 * n * r, 1))
Bk = np.matrix(np.identity(2 * n * r))
delta_k = delta_0
err = []
for i in xrange(T):
f_k = f(xk)
g_k = grad(xk)
pks = -delta_k * g_k / norm(g_k, 2)
gBg = (g_k.T * Bk * g_k)[0, 0]
if gBg <= 0:
tau_k = 1
else:
tau_k = min(1, norm(g_k, 2)**3 / (delta_k * gBg))
pk = tau_k * pks
# Update radius
rou_k = -(f_k - f(xk + pk)) / (g_k.T * pk + 0.5 * pk.T * Bk * pk)
rou_k = rou_k[0, 0]
if rou_k < 0.0001:
delta_k *= 0.25
else:
if rou_k > 0.75 and norm(pk, 2) == delta_k:
delta_k = min(2 * delta_k, delta_hat)
else:
delta_k = delta_k
if rou_k > eta:
xkp1 = xk + pk
# Update Bk
sk = xkp1 - xk
yk = grad(xkp1) - g_k
Bk += (yk * yk.T) / (yk.T * sk) - Bk * sk * sk.T * Bk / (sk.T *
Bk * sk)
xk = xkp1
else:
xk = xk
err.append(f(xk))
return xk, err
def init_subpopulations(self):
# Main excitatory subpopulation
self.e_size = int(self.params.network_group_size * .8)
self.group_e = self.subgroup(self.e_size)
self.group_e.C = self.pyr_params.C
self.group_e.gL = self.pyr_params.gL
self.group_e._refractory_time = self.pyr_params.refractory
# Main inhibitory subpopulation
self.i_size = int(self.params.network_group_size * .2)
self.group_i = self.subgroup(self.i_size)
self.group_i.C = self.inh_params.C
self.group_i.gL = self.inh_params.gL
self.group_i._refractory_time = self.inh_params.refractory
# Input-specific sub-subpopulations
self.groups_e = []
for i in range(self.params.num_groups):
subgroup_e = self.group_e.subgroup(int(self.params.f *
self.e_size))
self.groups_e.append(subgroup_e)
# Initialize state variables
self.vm = self.params.EL + randn(self.params.network_group_size) * mV
self.group_e.g_ampa_b = rand(
self.e_size) * self.pyr_params.w_ampa_ext_correct * 2.0
self.group_e.g_nmda = rand(self.e_size) * self.pyr_params.w_nmda * 2.0
self.group_e.g_gaba_a = rand(
self.e_size) * self.pyr_params.w_gaba * 2.0
self.group_i.g_ampa_r = rand(
self.i_size) * self.inh_params.w_ampa_rec * 2.0
self.group_i.g_ampa_b = rand(
self.i_size) * self.inh_params.w_ampa_ext * 2.0
#self.group_i.g_nmda = self.inh_params.w_nmda*100.0+10.0*nS*randn(self.i_size)
self.group_i.g_nmda = rand(self.i_size) * self.inh_params.w_nmda * 2.0
self.group_i.g_gaba_a = rand(
self.i_size) * self.inh_params.w_gaba * 2.0
def array_maxtrix_exercise():
print('===part of numpy array===\n')
'''
2. 建立一个一维数组 a 初始化为[4,5,6], (1)输出a 的类型（type）
(2)输出a的各维度的大小（shape）
(3)输出 a的第一个元素（值为4）
'''
a = np.array([4, 5, 6])
print(type(a), a.shape, a[0])
'''
3.建立一个二维数组 b,初始化为 [ [4, 5, 6],[1, 2, 3]] (1)输出各维度的大小（shape）
(2)输出 b(0,0)，b(0,1),b(1,1) 这三个元素（对应值分别为4,5,2）
'''
b = np.array([[4, 5, 6], [1, 2, 3]])
print(type(b), b.shape)
print(b[0][0], b[0][1], b[1][1])
'''
4. (1)建立一个全0矩阵 a, 大小为 3x3; 类型为整型（提示: dtype = int）
(2)建立一个全1矩阵b,大小为4x5;
(3)建立一个单位矩阵c ,大小为4x4;
(4)生成一个随机数矩阵d,大小为 3x2.
'''
print('\n===part of numpy matlib===\n')
c = mat.zeros((3, 3), dtype=int)
print(c)
d = mat.ones((4, 5), dtype=int)
print(d)
e = mat.identity(n=4, dtype=int)
e1 = mat.eye(n=4, M=5, k=0, dtype=int)
print(e)
print(e1)
f = mat.rand((3, 2))
print(f)
'''
5. 建立一个数组 a,(值为[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] ) ,
(1)打印a; (2)输出 下标为(2,3),(0,0) 这两个数组元素的值
'''
print('\n===part of array and matlib mix operation===\n')
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(a)
print(a[2][3], a[0][0])
'''
6.把上一题的 a数组的 0到1行 2到3列，放到b里面去，（此处不需要从新建立a,直接调用即可）
(1),输出b;(2) 输出b 的（0,0）这个元素的值
'''
b = a[0:2, 2:4]
print(b, b[0][0])
'''
7. 把第5题中数组a的最后两行所有元素放到 c中，（提示： a[1:2, :]）(1)输出 c ;
(2) 输出 c 中第一行的最后一个元素（提示，使用 -1 表示最后一个元素）
'''
c = a[-2:-1, :]
print(c[0][-1])
'''
8.建立数组a,初始化a为[[1, 2], [3, 4], [5, 6]]，
输出 （0,0）（1,1）（2,0）这三个元素（提示： 使用 print(a[[0, 1, 2], [0, 1, 0]]) ）
'''
a = np.array([[1, 2], [3, 4], [5, 6]])
print(a[[0, 1, 2], [0, 1, 0]])
'''
9.建立矩阵a ,初始化为[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]，输出(0,0),(1,2),(2,0),(3,1)
(提示使用 b = np.array([0, 2, 0, 1]) print(a[np.arange(4), b]))
'''
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
b = np.array([0, 2, 0, 1])
print(a[np.arange(4), b])
'''
10.对9 中输出的那四个元素，每个都加上10，然后重新输出矩阵a.(提示： a[np.arange(4), b] += 10 ）
'''
c = a[np.arange(4), b] + 10
print(c)
print("======= end of exercise1 ===== \n")
#-*-coding:utf-8-*-
"""
NumPy - 矩阵库
NumPy 包包含一个 Matrix库numpy.matlib。此模块的函数返回矩阵而不是返回ndarray对象。
"""
import numpy.matlib as mt
import numpy as np
if __name__ == '__main__':
#numpy.matlib.empty(shape, dtype, order)函数返回一个新的矩阵，而不初始化元素
print mt.empty((2, 2))
#numpy.matlib.zeros()返回以零填充的矩阵。
print mt.zeros((3, 3))
#numpy.matlib.ones()返回以一填充的矩阵。
print mt.ones((4, 4))
#numpy.matlib.eye(n, M,k, dtype)返回一个矩阵，对角线元素为 1，其他位置为零。
print mt.eye(n=5, M=5, k=0, dtype=float)
#numpy.matlib.identity()函数返回给定大小的单位矩阵。单位矩阵是主对角线元素都为 1 的方阵。
print mt.identity(5)
#numpy.matlib.rand()函数返回给定大小的填充随机值的矩阵。
print mt.rand(3, 3)
#矩阵总是二维的，而ndarray是一个 n 维数组。 两个对象都是可互换的。
m = np.matrix('1,2;3,4')
print m
print type(m)
print np.asarray(m)
# np_sc_calc.py: NumPyとSciPy
import numpy as np # NumPy
import numpy.matlib as npmat
import scipy.special as scspf # SciPy.specialパッケージ
# relerr : 相対誤差
from tktools import relerr # tktools.py: 私的作成関数
n = 10
# 乱数の種セット
np.random.seed(n)
# n個の乱数セット
a = npmat.rand(n)
print('a = ', a)
# 立方根
sc_c = scspf.cbrt(a) # SciPy.special
np_c = np.cbrt(a) # NumPy
# 相対誤差の最大値と最小値
relerr_vec = relerr(sc_c, np_c)
print('max(reldiff(sc_c, np_c)) = ', np.max(relerr_vec))
print('min(reldiff(sc_c, np_c)) = ', np.min(relerr_vec))
# expm1(a) = exp(a) - 1
sc_c = scspf.expm1(a)
np_c = np.exp(a) - 1
print(nm.empty((3, 3)))
#matlib zeros function
print(
"\n\nprinting the matrix with initializing the values with value \"0\" using zero function:"
)
print(nm.zeros((3, 3), dtype=int))
#matlib ones function
print(
"\n\nprinting the matrix with initializing the values with value \"1\" using ones function:"
)
print(nm.ones((3, 4), dtype=int))
#matlib eye function
print("\n\nprinting the matrix with diagonal elements values equals to 1:")
print(nm.eye(n=4, k=0, dtype=int, M=5))
#matlib identity function
print(
"\n\nprinting the identity matrix is the one with diagonal elements initializes to 1 and all other elements to zero:"
)
print(nm.identity(
5,
dtype=int,
))
#matlib random function
print("\n\nprinting the matrix with random values:")
print(nm.rand((5, 5)))
import numpy as np
import numpy.matlib as mat
import numpy.linalg as linalg
import time
import sys
runs = 10
n = 1000
A = mat.rand((n,n))
b = mat.rand((n,1))
total_time = 0
for i in range(0,runs):
start = time.perf_counter()
x = linalg.solve(A,b)
stop = time.perf_counter()
print('.', end="",flush=True)
total_time += (stop-start)
print()
print(runs, 'solves of Ax=b for A of size',n,'took',total_time,'seconds',
'for an average time of',total_time/runs,'seconds per solve.')
total_time = 0
for i in range(0,runs):
start = time.perf_counter()
U,s,V = linalg.svd(A)
stop = time.perf_counter()
print('.', end="",flush=True)
total_time += (stop-start)
print()
print(runs, 'SVD factorizations of A of size',n,'took',total_time,'seconds',
'for an average time of',total_time/runs,'seconds per solve.')
from scapy.all import * import matplotlib.pyplot as plt from numpy.matlib import rand # matplotlib.get_backend() # plt.ion() a = rand(100) b = rand(100) ans, unans = sr(IP(dst="www.bbc.co.uk") / TCP(sport=[RandShort()] * 1000), timeout=1) # plt.show(ans.plot(lambda x: x[1].id)) # plt.show(ans.scatter(lambda x: x[1].id)) plt.scatter(a, b) plt.show()
plt.annotate(str(ch), xy=(ch + 1, p + .5), va='center')
# cutomize ticks
ticks = plt.yticks(pos + .5, city)
xt = plt.xticks()[0]
plt.xticks(xt, [' '] * len(xt))
# minimize chartjunk
remove_border(left=False, bottom=False)
plt.grid(axis='x', color='white', linestyle='-')
# set plot limits
plt.ylim(pos.max(), pos.min() - 1)
plt.xlim(0, 30)
df2 = DataFrame(rand(10, 4), columns=['a', 'b', 'c', 'd'])
df2.plot(kind='bar')
df2.plot(kind='bar',
stacked=True) #Пропорциональное распределение значений
df2.plot(kind='barh', stacked=True) #Отображ горизонтально
##########################################################
years = np.arange(2004, 2009)
heights = np.random.random(years.shape) * 7000 + 3000
box_colors = brewer2mpl.get_map('Set1', 'qualitative', 5).mpl_colors
plt.bar(years - .4, heights, color=box_colors)
def assign_account_number(self):
self.account_number=round(float(rand(1))*100000,0);
print(str('Your account number is {}').format(self.account_number));
def test_suite_1():
n1 = 100
n2 = 100
n = n1+n2
d = 5
eta = .1
degree = 3
iterations = 1
results = mat.zeros((8,5))
times = mat.zeros((1,5))
sigma = 2
# 1st col is non-kernelized
# 2nd col is poly-kernel
for itr in xrange(iterations):
X = mat.randn(n1,d)
Phi_X = poly.phi(X, degree)
D0 = X + mat.rand(n2,d) / 1000
# Verify identity K(X,X) = 1
D1 = mat.randn(n2,d)
# How does kernel perform iid data
D2 = mat.rand(n2,d)
# Uniform rather than normal distribution
D3 = mat.randn(n2,d) * 2 + 2
# Linear transformation
D4 = mat.power(mat.randn(n2,d) + 1 ,3)
#Non-linear transformation
D5 = mat.power(X+1,3)
#non-linear transformation of the D0 dataset;
D6 = mat.rand(n2,d)/100 + mat.eye(n2,d)
#Totally different data - should have low similarity
D7 = mat.rand(n2,d)/100 + mat.eye(n2,d)*5
# Scaled version of D7
Data = [D0, D1, D2, D3, D4, D5, D6, D7]
for idx in xrange(8):
D = Data[idx]
start = time.time()
results[idx, 0] += nk_bhatta(X, D, 0)
nk = time.time()
emp = time.time()
results[idx, 1] += Bhattacharrya(X,D,gaussk(sigma),eta,5)
e5 = time.time()
results[idx, 2] += Bhattacharrya(X,D,gaussk(sigma),eta,15)
e15 = time.time()
results[idx, 3] += Bhattacharrya(X,D,gaussk(sigma),eta,25)
e25 = time.time()
nktime = nk-start
emptime = emp-nk
e5time = e5-emp
e15time = e15-e5
e25time = e25-e15
print "nk: {:.1f}, emp: {:.1f}, e5: {:.1f}, e15: {:.1f}, e25: {:.1f}".format(nktime, emptime, e5time, e15time, e25time)
times[0,0]+= nktime
times[0,4]+= emptime
times[0,1]+= e5time
times[0,2]+= e15time
times[0,3]+= e25time
# -*- encoding: utf-8 -*-
"""
4.6.1 创建矩阵
"""
import numpy as np
import numpy.matlib as mat
print(np.mat([[1, 2, 3], [4, 5, 6]], dtype=np.int)) # 使用列表创建矩阵
print(np.mat(np.arange(6).reshape((2, 3)))) # 使用数组创建矩阵
print(np.mat('1 4 7; 2 5 8; 3 6 9')) # 使用Matlab风格的字符串创建矩阵
print(mat.zeros((2, 3))) # 全0矩阵
print(mat.ones((2, 3))) # 全1矩阵
print(mat.eye(3)) # 单位矩阵
print(mat.empty((2, 3))) # 空矩阵
print(mat.rand((2, 3))) # [0,1)区间随机数矩阵
print(mat.randn((2, 3))) # 均值0方差1的高斯（正态）分布矩阵
import numpy as np
from matplotlib.pyplot import plot, show
from numpy.matlib import rand
from proj_pocos.well_stimulation.fracking.productivity_index import PseudoSteadyFlow
re = 6400
rw = 1.
k = float(rand(1))
h = float(rand(1))
B = float(rand(1))
mu = float(rand(1))
j_no_skin = PseudoSteadyFlow(k, h, B, mu, re, rw, skin=0.0).productivity_index
skins = np.linspace(-5, 25, 100)
folds_of_increase = []
for s in skins:
j = PseudoSteadyFlow(k, h, B, mu, re, rw, skin=s).productivity_index
folds_of_increase.append(j / j_no_skin)
plot(skins, folds_of_increase)
show()
def print_error(x_exact, x_approx):
print("Approximation error: ",
np.max(np.abs(x_exact - x_approx).A1 / np.abs(x_exact).A1))
if __name__ == '__main__':
import time
N_TESTS = 1000
T = 0.001
dt = 2e-3
n = 16 * 3 * 2
n2 = int(n / 2)
stiffness = 1e5
damping = 1e2
x0 = matlib.rand((n, 1))
a = matlib.rand((n, 1))
U = matlib.rand((n2, n2))
Upsilon = U * U.T
K = matlib.eye(n2) * stiffness
B = matlib.eye(n2) * damping
A = matlib.block([[matlib.zeros((n2, n2)),
matlib.eye(n2)], [-Upsilon * K, -Upsilon * B]])
#A = matlib.rand((n, n))
# print("x(0) is:", x0.T)
# print("a is: ", a.T)
print("State size n:", n)
print("Eigenvalues of A:", np.sort_complex(eigvals(A)).T)
print("")
previousNbrOfNeurons = settings_obj.NetworkArch[i]
Chromosomes = [] #population size * chromosome length
# for i in range(GA.populationSize):
# l = []
# for j in range(GA.chromosomeLength):
# l.append(0)
# Chromosomes.append(l)
#initialized by zero
Chromosomes_Fitness= [] #population size
for i in range(GA.populationSize):
Chromosomes_Fitness.append(0)
BestFitness_perGeneration = [] #number of max generations
AvgFitness_perGeneration = [] #number of max generations
for i in range(GA.nbrOfGenerations_max):
BestFitness_perGeneration.append(-1) #intialize with -1
AvgFitness_perGeneration.append(-1) #intialize with -1
#Initializing chromosomes weights range with values from -1 to 1
for pop in range(GA.populationSize):
l = numpy.array(GA.weightsRange * (2 * rand(1, GA.chromosomeLength) - 1)).reshape(-1,).tolist()# -1<value<1
Chromosomes.append(l)
settings_obj.collison_value()
MoveCars(env, settings_obj.nbrOfTimeStepsToTimeout, GA, settings_obj.dt,sensor, car, settings_obj.num,
settings_obj.smallXYVariance, Chromosomes_Fitness, Chromosomes, settings_obj.NetworkArch, settings_obj.unipolarBipolarSelector, settings_obj.collision_distance)
def step():
return sign(rand(1) - .5)
input_conn_names = ['ee_input']
for name in input_connection_names:
print 'create connections between', name[0], 'and', name[1]
for connType in input_conn_names:
connName = name[0] + connType[0] + name[1] + connType[1]
weightMatrix = get_matrix_from_file(weight_path + connName + '.npy')
print weightMatrix.shape
synapses_XeAe = Synapses(input_groups[connName[0:2]],
neuron_groups[connName[2:4]],
model=eqs_stdp_ee,
on_pre=eqs_stdp_pre_ee,
on_post=eqs_stdp_post_ee,
method='linear')
synapses[connName] = synapses_XeAe
synapses[connName].connect()
synapses[connName].delay = rand() * delay['ee_input']
synapses[connName].w = weightMatrix.flatten()
#------------------------------------------------------------------------------
# run the simulation and set inputs
#------------------------------------------------------------------------------
fig_num = 1
input_weight_monitor, fig_weights = plot_2d_input_weights()
#fig_num += 1
input_groups['Xe'].rates = 0 * Hz
defaultclock.dt = 0.5 * ms
run(0 * second)
j = 0
# @Desc : 矩阵
import numpy as np
import numpy.matlib as ml
print ("empty")
print(ml.empty((3, 3), dtype=np.int, order='F'))
print(ml.empty((3, 3), dtype=np.int, order='C'))
print ("\nzeros")
print(ml.zeros((3, 3), dtype=np.int, order='C'))
print ("\nones")
print(ml.ones((3, 3), dtype=np.int, order='C'))
print ("\neye")
print(ml.eye(3, dtype=np.int, order='C'))
print ("\nidentity")
print(ml.identity(3, dtype=np.int))
print ("\nrand")
print(ml.rand(2, 3))
print ("\nmatrix")
a = np.arange(12).reshape(3, 4)
mr = ml.matrix(a)
print (a)
print (mr)
print (type(a))
print (type(mr))
print Sm #to get some insight before everything dies
try:
from scipy import linalg as sl
evals = sl.eigvals(Cmat, Sm)
evals.sort() # in-place!
except: # we give up, and place -1's in the return 1d-array
evals = ones(n).A1 * (-1)
# default axis in cumsum works here:
return evals.cumsum()
#############################################################
# test cases:
if __name__ == '__main__':
from numpy.matlib import rand
data = rand((100, 3))
print getDeterministics(100, 'ctl', 0.3).shape
print getDeterministics(100, 'c', 5).shape
print getDeterministics(100, 'ctlsi', 80).shape
print getDeterministics(100, 'qmtl', 0.1).shape
print autocovar(data, 10)
print autocovar(data, 5, True)
print longrunvar(data)
# the following could raise exceptions due to non-pos-def matrices
print commontrendstest(data)
print commontrendstest(data,2,'t',0.3)
print commontrendstest(data,4,'2a',0.3)
print commontrendstest(data,3,'1',0.3)
try: print commontrendstest(data,5,'2',0.8)
except: print '5 lags failed'
# check loop for sorting evals:
C[i, j] = acc
return C
def matrix_multiply(A, B):
m, n = A.shape
n, r = B.shape
C = zeros((m, r), float64)
for i in range(m):
for j in range(r):
acc = 0
for k in range(n):
acc += A[i, k] * B[k, j]
C[i, j] = acc
return C
n = 1000
A = rand(n, n)
B = rand(n, n)
from time import time
t1 = time()
matrix_multiply_jit(A, B)
t2 = time()
print(t2 - t1)
matrix_multiply(A, B)
t3 = time()
print(t3 - t2)
print((t3 - t2) / (t2 - t1))
def rand_file_name(ext):
from numpy import *
import numpy.matlib as npmlib
index = int(floor((1000000*npmlib.rand((1,1)))))
return 'file'+str(index)+ext
