def _init_params(self, X):
init = self.init
n_samples, n_features = X.shape
n_components = self.n_components
if (init == 'kmeans'):
km = Kmeans(n_components)
clusters, mean, cov = km.cluster(X)
coef = sp.array([c.shape[0] / n_samples for c in clusters])
comps = [multivariate_normal(mean[i], cov[i], allow_singular=True)
for i in range(n_components)]
elif (init == 'rand'):
coef = sp.absolute(sprand.randn(n_components))
coef = coef / coef.sum()
means = X[sprand.permutation(n_samples)[0: n_components]]
clusters = [[] for i in range(n_components)]
for x in X:
idx = sp.argmin([spla.norm(x - mean) for mean in means])
clusters[idx].append(x)
comps = []
for k in range(n_components):
mean = means[k]
cov = sp.cov(clusters[k], rowvar=0, ddof=0)
comps.append(multivariate_normal(mean, cov, allow_singular=True))
self.coef = coef
self.comps = comps
def train(self, dataset, targets, lamda=0):
""" dataset: matrix of dimensions n x input
targets: column vector of dimension n x output """
# Choose random center vectors from training set
self.centers = random.permutation(dataset)[:self.hidden_length]
# Calculate data variance
self.variance = np.var(dataset)
# Calculate activations of RBFs
green_matrix = self.calc_activation(dataset)
# Calculate output weights
if lamda == 0:
self.W = dot(pinv(green_matrix), targets) # With pseudoinverse
else:
green_matrix_transpose = np.transpose(green_matrix)
# With operator lambda
self.W = dot(inv(dot(green_matrix_transpose, green_matrix) + lamda * np.identity(self.hidden_length)),
dot(green_matrix_transpose, targets))
# Get error
result = self.test(dataset)
error = self.cost_function(targets, result)
return error
def fit(self, X):
n_samples, n_features = X.shape
n_classes = self.n_classes
max_iter = self.max_iter
tol = self.tol
rand_center_idx = sprand.permutation(n_samples)[0:n_classes]
center = X[rand_center_idx].T
responsilibity = sp.zeros((n_samples, n_classes))
for iter in range(max_iter):
# E step
dist = sp.expand_dims(X, axis=2) - sp.expand_dims(center, axis=0)
dist = spla.norm(dist, axis=1)**2
min_idx = sp.argmin(dist, axis=1)
responsilibity.fill(0)
responsilibity[sp.arange(n_samples), min_idx] = 1
# M step
center_new = sp.dot(X.T, responsilibity) / sp.sum(responsilibity, axis=0)
diff = center_new - center
print('K-Means: {0:5d} {1:4e}'.format(iter, spla.norm(diff) / spla.norm(center)))
if (spla.norm(diff) < tol * spla.norm(center)):
break
center = center_new
self.center = center.T
self.responsibility = responsilibity
return self
def generate_data(N=100, true_params=secret_true_params, seed=42):
x = np.linspace(-2.5, 2.5, N)
y1 = my_model(x, *true_params)
y2 = 1.0 * random.normal(size=N)
# Create the data
data = np.array([x, y1 + y2]).T
# Shuffle the data
permuted_data = random.permutation(data)
# Save the data
np.savetxt("dataN%d.txt" % N, data)
return data
def generate_data(N=100, true_params=secret_true_params,
seed = 42):
x = np.linspace(-2.5, 2.5, N)
y1 = my_model(x, *true_params)
y2 = 1.0 * random.normal(size=N)
# Create the data
data = np.array([x,y1+y2]).T
# Shuffle the data
permuted_data = random.permutation(data)
# Save the data
np.savetxt("dataN%d.txt"%N, data)
return data
def setUpNextState(initial_state, server_prob, n_process=n_process):
sum_initial_state = sum(initial_state)
arrival_times = getRandomArrivalServiceTimes(n_process, arrival_rate, None)[0]
time_start = arrival_times[sum_initial_state]
# next two lines optimizes to avoid the processing of whole queeue, instead only processes which are needed
# are processed
arrival_times = arrival_times[arrival_times <= (time_start+time_interval)]
n_process= arrival_times.size
initial_states = zip(initial_state, [arrival_times[sum_initial_state]] * len(initial_state))
server_address_table_forced = random.permutation(concatenate([ones(state) * i for i,state in enumerate(initial_state)]))
server_address_table = concatenate([server_address_table_forced, digitize(uniform.rvs(size = n_process- sum_initial_state), cumsum(server_prob))])
server_arrival_times = [arrival_times[server_address_table == i] for i in range(n_server)]
server_service_times = [getRandomArrivalServiceTimes((server_address_table == i).sum(), None, service_rate[i])[1] for i in range(n_server)]
results = map(mm1, server_arrival_times, server_service_times, initial_states)
final_state = [r['queue_size_by_time'](time_start+time_interval, max_no_people) if r else 0 for r in results]
return tuple(final_state)
def fit(self, X, Y):
"""fitting network with given X, Y
:param X: matrix of dimensions n x indim
:type X: [type]
:param Y: column vector of dimension n x 1
:type Y: [type]
"""
# choose random center vectors from training set
rnd_idx = random.permutation(X.shape[0])[:self.numCenters]
self.centers = [X[i, :] for i in rnd_idx]
# calculate activations of RBFs
G = self._calcAct(X)
# calculate output weights (pseudoinverse)
self.W = dot(pinv(G), Y)
def set_random_centers(self, X):
# choose random center vectors from training set
rnd_idx = random.permutation(X.shape[0])[:self.n_centers]
self.centers = [X[i, :] for i in rnd_idx]
self.beta = np.full(self.n_centers, 8.0)
print('center: {}'.format(self.centers))
arrival_rate = 1
service_rate = 1/6.0 * ones(3) #array([1.09, 2.000005, 1])
server_prob = array([0.25, 0.25, 0.5])
n_server = server_prob.size
n_process = 100
time_interval = 10
initial_state = (7,2,3)
arrival_times = getRandomArrivalServiceTimes(n_process, arrival_rate, None)[0]
sum_initial_state = sum(initial_state)
# preparing initial state for each mm1 simulation
initial_states = zip(initial_state, [arrival_times[sum_initial_state]] * len(initial_state))
# maps kth process to ith server
server_address_table_forced = random.permutation(concatenate([ones(state) * i for i,state in enumerate(initial_state)]))
print "forced server address table", server_address_table_forced
server_address_table = concatenate([server_address_table_forced, digitize(uniform.rvs(size = n_process-sum_initial_state), cumsum(server_prob))])
server_arrival_times = [arrival_times[server_address_table == i] for i in range(n_server)]
server_service_times = [
getRandomArrivalServiceTimes((server_address_table == i).sum(), None, service_rate[i])[1]
for i in range(n_server)
]
results = map(mm1, server_arrival_times, server_service_times, initial_states)
print "Mean QueueSize(1)", array([mean(result['queue_size']) for result in results])
print "Results[0]['queue_size']", results[0]['queue_size']
print "Results[1]['queue_size']", results[1]['queue_size']
print "Results[2]['queue_size']", results[2]['queue_size']
time_start = arrival_times[sum_initial_state] # I don't know why it shouldn't be sum_initial_state +1 instead
print "queue_size_by_time", time_start, [r['queue_size_by_time'](time_start) for r in results]
filenames = []
testset = []
indir = 'train'
for file in os.listdir(indir):
if(file.endswith('.jpg')):
filenames.append(file)
testdir = 'test'
for file in os.listdir(testdir):
if(file.endswith('.jpg')):
testset.append(file)
for i in xrange(len(whales)):
if(labelsDict[whales[i]] == -1):
labelsDict[whales[i]] = []
labelsDict[whales[i]].append(images[i])
testset = [int(re.search("w_(\\d+)\.jpg", x).group(1)) for x in testset]
for w in set(whales):
allExamplesForW = labelsDict[w]
allExamplesForW = [x for x in allExamplesForW if x not in testset]
allExamplesForW = random.permutation(allExamplesForW)
for i in allExamplesForW[0:(len(allExamplesForW)/2)+(random.randint(0,(len(allExamplesForW))%2+1))]:
print("copying %d\n"%i)
os.rename(("%s/w_%d.jpg") % (indir, i), ("%s/w_%d.jpg") %(validationDir, i))
def get_random_batch(self, batchSize):
randInd = random.permutation(len(self.images))[:batchSize]
return self.read_images([os.path.join(self.inputDir, x) for x in self.images[randInd]]), self.yTrain[randInd]
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from scipy import random as sprd from lstm import LSTM n = 10 x = sprd.permutation(n) t = list(reversed(x)) hidden_size = 4 vocab_size = n lstm = LSTM(vocab_size, hidden_size) lstm.check_gradient(x, t)
A = 5
E = 1.0
L = 2.0
myseed = 42
# Initialize the random with seed
random.seed(myseed)
# Hidden Model
x = np.linspace(-L, L, N)
y1 = A * np.cos(0.5*np.pi*x/L)
y2 = E * random.normal(size=N)
# Show
plt.plot(x, y1+y2, 'bs', alpha=0.5, label="Medicion")
plt.plot(x, y1, 'k-', lw=2.0, label="Relacion determinista")
plt.xlim([-2.5,2.5])
plt.ylim([-5,10])
plt.xlabel("x []")
plt.ylabel("y []")
plt.legend(numpoints=1, loc="lower center")
#plt.savefig("images/dataN%d.png"%N)
plt.show()
# Shuffle the data
data = np.array([x,y1+y2]).T
data = random.permutation(data)
# Save
np.savetxt("../data/data.txt", data)
def get_batch(self, size):
randInd = random.permutation(len(self.train))[:size]
return self.read_images([os.path.join(self.inputDir, x) for x in self.train[randInd]]), self.trainLabels[randInd]
def siPermutation(X, times = 1):
for i in xrange(times):
X = random.permutation(X)
return X
def main():
from argparse import ArgumentParser, RawDescriptionHelpFormatter
headerhelp = \
'''
'''
parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter,
description=headerhelp)
parser.add_argument('inpath', help='The input mTZ file.')
parser.add_argument('-n',
'--nobs-per-shell',
type=int,
default=1000,
help='Number of observations per shaell target.')
args = parser.parse_args()
from pymtz import read_mtz_file
from scipy import random, corrcoef, array, nonzero, zeros, ones
from scipy.stats import spearmanr
from matplotlib.pyplot import figure, show
print("Reading ", args.inpath, end='...', flush=True)
dataset = read_mtz_file(args.inpath)
print("done")
Nmeas = dataset.GetReflectionNumber()
print("Found %d measurements" % Nmeas)
ashes = dataset.GetHKLhash()
uniqhkl = set(ashes)
Nunq = len(uniqhkl)
Nshells = int(Nunq / args.nobs_per_shell)
Ihl, shl = array(dataset.reflections).T[nonzero([
(t in ['I', 'SIGI']) for t in dataset.GetLabels()
])[0]]
whl = 1 / shl**2
hkldict = dict.fromkeys(uniqhkl)
for (i, ash) in enumerate(ashes):
if hkldict[ash]:
hkldict[ash].append(i)
else:
hkldict[ash] = [i]
print("Found %d unique reflections" % (Nunq))
print("Will subdivide data into %d resolution shells" % Nshells)
edges = dataset.GetResolutionShells(Nshells)
shell_column = dataset.GetShellColumn(edges)
d12, cc12, sp12, p12, Ish = [], [], [], [], []
for i in range(Nshells):
Ish1, Ish2, shkl = [], [], []
shind = (shell_column == i)
for ash in set(ashes[shind]):
mcity = len(hkldict[ash])
if mcity > 1:
Nhalf = int(mcity / 2)
wr = list(ones(Nhalf)) + list(zeros(Nhalf))
if len(wr) < mcity:
wr.append(random.random_integers(0, 1))
wr = random.permutation(wr)
Ish1.append(
sum(wr * Ihl[hkldict[ash]] * whl[hkldict[ash]]) /
sum(wr * whl[hkldict[ash]]))
Ish2.append(
sum((1 - wr) * Ihl[hkldict[ash]] * whl[hkldict[ash]]) /
sum((1 - wr) * whl[hkldict[ash]]))
shkl.append(dataset.hash2hkl(ash))
cc12.append(corrcoef(Ish1, Ish2)[0][1])
sp12t, p12t = spearmanr(Ish1, Ish2)
sp12.append(sp12t)
p12.append(p12t)
Ish.append([Ish1, Ish2, shkl])
d12.append(dataset.GetResolutionColumn()[shind].mean())
print("%4d %7.2f %7.2f %7.2f %8d %5.3f %5.3f %6.3g" %
(i + 1, edges[i], edges[i + 1], d12[-1], sum(shind), cc12[-1],
sp12t, p12t))
Ish_fig = figure(FigureClass=KDWindow)
Ish_fig.set_data([Ish, array(d12), cc12, sp12])
Ish_fig.plot()
Ish_fig.canvas.mpl_connect('key_press_event', Ish_fig.onkeypress)
show()
