Python numpy 模块，asscalar() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.asscalar()。
def _send_sparseOutput(self, output, timestamp, name):
for out in self._sparseOutput_threads:
if isinstance(out, str): # LSL outlet
raise NotImplementedError
else: # OSC output stream
if USE_LIBLO:
if (np.array(output).size==1):
new_output = [('f', np.asscalar(output))]
message = Message('/{}'.format(name), *new_output)
else:
new_output = [('f', x) for x in output[:]]
message = Message('/{}'.format(name), *new_output)
#send(out, Bundle(timestamp, message))
send(out, message)
else:
raise NotImplementedError
if self.verbose:
print('spareOutput: {}'.format(output))
def predict(self):
try:
X, Wm, Wc = sigmaPoints(self.xa, self.Pa)
except:
warnings.warn('Encountered a matrix that is not positive definite in the sigma points calculation at the predict step')
self.Pa = nearpd(self.Pa)
X, Wm, Wc = sigmaPoints(self.xa, self.Pa)
fX, x, Pxx = unscentedTransform(X, Wm, Wc, self.fa)
x = np.asscalar(x)
Pxx = np.asscalar(Pxx)
Pxv = 0.
N = np.shape(X)[1]
for j in range(0, N):
Pxv += Wc[j] * fX[0,j] * X[3,j]
self.xa = np.array( ((x,), (0.,), (0.,), (0.,)) )
self.Pa = np.array( ((Pxx, Pxv , 0. , 0. ),
(Pxv, self.R, 0. , 0. ),
(0. , 0. , self.Q , self.cor),
(0. , 0. , self.cor, self.R )) )
def Saliency_map(image,model,preprocess,ground_truth,use_gpu=False,method=util.GradType.GUIDED):
vis_param_dict['method'] = method
img_tensor = preprocess(image)
img_tensor.unsqueeze_(0)
if use_gpu:
img_tensor=img_tensor.cuda()
input = Variable(img_tensor,requires_grad=True)
if input.grad is not None:
input.grad.data.zero_()
model.zero_grad()
output = model(input)
ind=torch.LongTensor(1)
if(isinstance(ground_truth,np.int64)):
ground_truth=np.asscalar(ground_truth)
ind[0]=ground_truth
ind=Variable(ind)
energy=output[0,ground_truth]
energy.backward()
grad=input.grad
if use_gpu:
return np.abs(grad.data.cpu().numpy()[0]).max(axis=0)
return np.abs(grad.data.numpy()[0]).max(axis=0)
def mean(self,*,axis=None):
"""Returns the mean of firing rate (in Hz).
Parameters
----------
axis : int, optional
When axis is None, the global mean firing rate is returned.
When axis is 0, the mean firing rates across units, as a
function of the external correlate (e.g. position) are
returned.
When axis is 1, the mean firing rate for each unit is
returned.
Returns
-------
mean :
"""
means = np.mean(self.ratemap, axis=axis).squeeze()
if means.size == 1:
return np.asscalar(means)
return means
def max(self,*,axis=None):
"""Returns the mean of firing rate (in Hz).
Parameters
----------
axis : int, optional
When axis is None, the global mean firing rate is returned.
When axis is 0, the mean firing rates across units, as a
function of the external correlate (e.g. position) are
returned.
When axis is 1, the mean firing rate for each unit is
returned.
Returns
-------
mean :
"""
maxes = np.max(self.ratemap, axis=axis).squeeze()
if maxes.size == 1:
return np.asscalar(maxes)
return maxes
def min(self,*,axis=None):
"""Returns the mean of firing rate (in Hz).
Parameters
----------
axis : int, optional
When axis is None, the global mean firing rate is returned.
When axis is 0, the mean firing rates across units, as a
function of the external correlate (e.g. position) are
returned.
When axis is 1, the mean firing rate for each unit is
returned.
Returns
-------
mean :
"""
mins = np.min(self.ratemap, axis=axis).squeeze()
if mins.size == 1:
return np.asscalar(mins)
return mins
def inject_summaries(self, idx):
if len(self._stats_mean_qvalues) > 0:
self.visualize(idx, "%s/episode mean q" % self.name,
np.asscalar(np.mean(self._stats_mean_qvalues)))
self.visualize(idx, "%s/episode mean stddev.q" % self.name,
np.asscalar(np.mean(self._stats_stddev_qvalues)))
if len(self._stats_loss) > 0:
self.visualize(idx, "%s/episode mean loss" % self.name,
np.asscalar(np.mean(self._stats_loss)))
if len(self._stats_rewards) > 0:
self.visualize(idx, "%s/episode mean reward" % self.name,
np.asscalar(np.mean(self._stats_rewards)))
# Reset
self._stats_mean_qvalues = []
self._stats_stddev_qvalues = []
self._stats_loss = []
self._stats_rewards = []
def inject_summaries(self, idx):
if len(self._stats_mean_qvalues) > 0:
self.visualize(idx, "%s/episode mean q" % self.name,
np.asscalar(np.mean(self._stats_mean_qvalues)))
self.visualize(idx, "%s/episode mean stddev.q" % self.name,
np.asscalar(np.mean(self._stats_stddev_qvalues)))
if len(self._stats_loss) > 0:
self.visualize(idx, "%s/episode mean loss" % self.name,
np.asscalar(np.mean(self._stats_loss)))
if len(self._stats_rewards) > 0:
self.visualize(idx, "%s/episode mean reward" % self.name,
np.asscalar(np.mean(self._stats_rewards)))
# Reset
self._stats_mean_qvalues = []
self._stats_stddev_qvalues = []
self._stats_loss = []
self._stats_rewards = []
def _conjurePotentialPools(self, **kwargs):
# These only need to be fetched from the SP once.
if self._potentialPools:
return self._potentialPools
sp = self._sp
out = []
for colIndex in range(0, sp.getNumColumns()):
columnPool = self._getZeroedInput()
columnPoolIndices = []
sp.getPotential(colIndex, columnPool)
for i, pool in enumerate(columnPool):
if np.asscalar(pool) == 1.0:
columnPoolIndices.append(i)
out.append(columnPoolIndices)
self._potentialPools = out
return out
def delta_e_cie1994(color1, color2, K_L=1, K_C=1, K_H=1, K_1=0.045, K_2=0.015):
"""
Calculates the Delta E (CIE1994) of two colors.
K_l:
0.045 graphic arts
0.048 textiles
K_2:
0.015 graphic arts
0.014 textiles
K_L:
1 default
2 textiles
"""
color1_vector = _get_lab_color1_vector(color1)
color2_matrix = _get_lab_color2_matrix(color2)
delta_e = color_diff_matrix.delta_e_cie1994(
color1_vector, color2_matrix, K_L=K_L, K_C=K_C, K_H=K_H, K_1=K_1, K_2=K_2)[0]
return numpy.asscalar(delta_e)
# noinspection PyPep8Naming
def get_value(self, *args, **kwargs):
if len(args) == 2:
gradient = args[0]
nat_gradient = args[1]
tmp = np.asscalar(gradient.dot(nat_gradient))
lambda_v = np.sqrt(tmp / (4. * self._eps))
# For numerical stability
lambda_v = max(lambda_v, 1e-8)
step_length = 1. / (2. * lambda_v)
return step_length
elif len(args) == 1:
return self.get_value(args[0], args[0], **kwargs)
else:
raise ValueError('Adaptive parameters needs gradient or gradient'
'and natural gradient')
def choose_next_action(self, state):
network_output_v, network_output_pi, action_repeat_probs = self.session.run(
[
self.local_network.output_layer_v,
self.local_network.output_layer_pi,
self.local_network.action_repeat_probs,
],
feed_dict={
self.local_network.input_ph: [state],
})
network_output_pi = network_output_pi.reshape(-1)
network_output_v = np.asscalar(network_output_v)
action_index = self.sample_policy_action(network_output_pi)
new_action = np.zeros([self.num_actions])
new_action[action_index] = 1
action_repeat = 1 + self.sample_policy_action(action_repeat_probs[0])
return new_action, network_output_v, network_output_pi, action_repeat
def enspredict (Xval, indices):
'''
blend models using majority voting scheme
'''
totalLabelist = []
for ind in range (len(Xval)):
labelist = []
for model in featureSelectModel:
label = model.predict( Xval[:, indices ][ind].reshape(1, -1) )
labelist.append (np.asscalar (label) )
for model in wholeFeatureModel:
label = model.predict( Xval[ind].reshape(1, -1) )
labelist.append (np.asscalar (label) )
votedLabel = max ( set (labelist), key=labelist.count )
totalLabelist.append (votedLabel)
return totalLabelist
def question_batches(data_file):
"""Iterates over a dataset returning batches composed by a single question
and its candidate answers.
:data_file: a HDF5 file object holding the dataset
:returns: a DataSet namedtuple of arrays (questions, sentences, labels).
"""
n_questions = np.asscalar(data_file['metadata/questions/count'][...])
questions_ds = data_file['data/questions']
sentences_ds = data_file['data/sentences']
for i in range(n_questions):
row_labels = data_file['data/labels/q%d' % i][...]
labels = row_labels[:, 1]
rows = row_labels[:, 0]
questions = questions_ds[rows, ...]
sentences = sentences_ds[rows, ...]
yield DataSet(questions, sentences, labels)
def _optimize_single(self, x0):
x0 = list(x0)
if x0[0] == None:
x0[0] = 0
dt_ok = np.asscalar(self.dispersion.dt_ok(x0))
if dt_ok < 0:
# Initial conditions violate constraints, reject
return x0, None, float('inf')
x0[0] = dt_ok
x0[0] = min(x0[0], self.dtmax)
x0[0] = max(x0[0], self.dtmin)
x0 = np.asfarray(x0)
stencil_ok = self.dispersion.stencil_ok(x0)
if stencil_ok < 0:
# Initial conditions violate constraints, reject
return x0, None, float('inf')
res = scop.minimize(self.dispersion.norm, x0, method='SLSQP', constraints = self.constraints, options = dict(disp=False, iprint = 2))
norm = self.dispersion_high.norm(res.x)
return x0, res, norm
def zindex(self,z):
"""
redshift index lookup
parameters
----------
z: array of floats
returns
-------
indices: array of integers
redshift indices
"""
# return the z index/indices with rounding.
zind = np.searchsorted(self.zinteger,np.round(np.atleast_1d(z)*self.zbinscale).astype(np.int64))
if (zind.size == 1):
return np.asscalar(zind)
else:
return zind
# and check for top overflows. Minimum is always 0
#test,=np.where(zind == self.z.size)
#if (test.size > 0): zind[test] = self.z.size-1
def refmagindex(self,refmag):
"""
reference magnitude index lookup
parameters
----------
refmag: array of floats
returns
-------
indices: array of integers
refmag indices
"""
# return the refmag index/indices with rounding
refmagind = np.searchsorted(self.refmaginteger,np.round(np.atleast_1d(refmag)*self.refmagbinscale).astype(np.int64))
if (refmagind.size == 1):
return np.asscalar(refmagind)
else:
return refmagind
def lumrefmagindex(self,lumrefmag):
"""
luminosity reference magnitude index lookup
parameters
----------
lumrefmag: array of floats
returns
-------
indices: array of integers
lumrefmag indices
"""
lumrefmagind = np.searchsorted(self.lumrefmaginteger,np.round(np.atleast_1d(lumrefmag)*self.refmagbinscale).astype(np.int64))
if (lumrefmagind.size == 1):
return np.asscalar(lumrefmagind)
else:
return lumrefmagind
def __call__(self, o_):
if np.isscalar(o_):
o = torch.FloatTensor([o_])
else:
o = torch.FloatTensor(o_)
self.online_stats.feed(o)
if self.offline_stats.n[0] == 0:
return o_
std = (self.offline_stats.v + 1e-6) ** .5
o = (o - self.offline_stats.m) / std
o = o.numpy()
if np.isscalar(o_):
o = np.asscalar(o)
else:
o = o.reshape(o_.shape)
return o
def calculateQ(self, k):
Q = M(self.Q(k))
R = M(self.kf.R(k))
H = M(self.kf.H(k))
D = M(self.D[k-1])
alpha = np.trace(D - R) / np.trace(H * M(self.kf.Pminus[k-1]) * H.T)
alpha = np.asscalar(alpha)
if np.isfinite(alpha) and alpha>0:
alpha = np.power(alpha, self.exponent)
alpha = max(0.0001, min(alpha, 1000.*mt.trace(R) / mt.trace(Q)))
else:
alpha = 0.0001
Q = Q * alpha
self.alpha[k] = alpha
return Q
def __call__(self, o_):
if np.isscalar(o_):
o = torch.FloatTensor([o_])
else:
o = torch.FloatTensor(o_)
self.online_stats.feed(o)
if self.offline_stats.n[0] == 0:
return o_
std = (self.offline_stats.v + 1e-6) ** .5
o = (o - self.offline_stats.m) / std
o = o.numpy()
if np.isscalar(o_):
o = np.asscalar(o)
else:
o = o.reshape(o_.shape)
return o
def learn(self, target, epoch=None):
BasicLearner.learn(self, target, epoch)
error = np.asscalar(target - self.y)
self.beta += self.theta * error * self.h * np.asarray(self.phi).flatten()
self.alpha = np.exp(self.beta)
self.W += np.matrix(self.alpha * error * np.asarray(self.phi).flatten()).T
self.U += self.stepSize * self.m
phi_2 = np.asarray(np.power(self.phi, 2)).flatten()
m_decay = 1 - self.theta * np.power(self.h, 2) * phi_2
m_delta = error * self.h * np.asarray(self.X.T * self.gradientAct(self.phi, self.net))
self.m = m_decay * self.m + self.theta * m_delta
h_decay = 1 - self.alpha * phi_2
h_delta = error * self.alpha * np.asarray(self.phi).flatten()
self.h = h_decay * self.h + h_delta
return 0.5 * error * error
# TODO: refactor classification learner
def _dcoord(coord):
"""determine the spacing of a coordinate"""
coord = np.array(coord)
if coord.ndim > 1:
msg = 'Only 1D coordinates are supported'
raise AssertionError(msg)
dcoord = np.unique(np.round(np.diff(coord), 4))
# irregularly spaced
if dcoord.size > 1:
dcoord_str = 'irr'
# regularly spaced
else:
dcoord_str = '{:0.2f}'.format(np.asscalar(dcoord))
return dcoord_str
def inject_summaries(self, idx):
if len(self._stats_mean_qvalues) > 0:
self.visualize(idx, "%s/episode mean q" % self.name,
np.asscalar(np.mean(self._stats_mean_qvalues)))
self.visualize(idx, "%s/episode mean stddev.q" % self.name,
np.asscalar(np.mean(self._stats_stddev_qvalues)))
if len(self._stats_loss) > 0:
self.visualize(idx, "%s/episode mean loss" % self.name,
np.asscalar(np.mean(self._stats_loss)))
if len(self._stats_rewards) > 0:
self.visualize(idx, "%s/episode mean reward" % self.name,
np.asscalar(np.mean(self._stats_rewards)))
# Reset
self._stats_mean_qvalues = []
self._stats_stddev_qvalues = []
self._stats_loss = []
self._stats_rewards = []
def buildPlayerGameActivationsTable(self, model=None):
if model is None:
print("using default model")
model = self.narrowGameModel.model()
print("getting players")
engines = self.env.playerDB.byEngine(True)
legits = self.env.playerDB.byEngine(False)
print("got " + str(len(engines + legits)) + " players")
playerGameActivations = []
for player in engines + legits:
print("predicting " + player.id)
gs = GameAnalysisStore.new()
gs.addGameAnalyses(self.env.gameAnalysisDB.byUserId(player.id))
predictions = self.predict(gs.gameAnalysisTensors(), model)
playerGameActivations.append(PlayerGameActivations(player.id, player.engine, [int(100*np.asscalar(p[0][0][0])) for p in predictions]))
print("writing to DB")
self.env.playerGameActivationsDB.lazyWriteMany(playerGameActivations)
def rotg(self, a, b):
'''Compute the given rotation matrix given a column vector (a, b).
Returns r, z, c, s.
r: r = a ** 2 + b ** 2.
z: Use to recover c and s.
if abs(z) < 1:
c, s = 1 - z ** 2, z
elif abs(z) == 1:
c, s = 0, 1
else:
c, s = 1 / z, 1 - z ** 2
c: Cosine element of the rotation matrix.
s: Sine element of the rotation matrix.
'''
a, b = np.asarray(a), np.asarray(b)
_sentry_same_dtype(a, b)
fn = self._dispatch(self.rotg.vtable, a.dtype)
return fn(np.asscalar(a), np.asscalar(b))
def calc_ba_data(self, probe_simmat, multi_probe_list):
# make thr range
probe_simmat_mean = np.asscalar(np.mean(probe_simmat))
thr1 = max(0.0, round(min(0.9, round(probe_simmat_mean, 2)) - 0.1, 2)) # don't change
thr2 = round(thr1 + 0.2, 2)
# use bayes optimization to find best_thr
if SaverConfigs.PRINT_BAYES_OPT:
print('Finding best thresholds between {} and {} using bayesian-optimization...'.format(thr1, thr2))
gp_params = {"alpha": 1e-5, "n_restarts_optimizer": 2}
func_to_be_opt = partial(self.calc_probe_ba_list, probe_simmat, multi_probe_list, True)
bo = BayesianOptimization(func_to_be_opt, {'thr': (thr1, thr2)}, verbose=SaverConfigs.PRINT_BAYES_OPT)
bo.explore({'thr': [probe_simmat_mean]})
bo.maximize(init_points=2, n_iter=SaverConfigs.NUM_BAYES_STEPS,
acq="poi", xi=0.001, **gp_params) # smaller xi: exploitation
best_thr = bo.res['max']['max_params']['thr']
# calc probe_ba_list with best_thr
probe_ba_list = self.calc_probe_ba_list(probe_simmat, multi_probe_list, False, best_thr)
probe_ba_list = np.multiply(probe_ba_list, 100).tolist()
# make avg_probe_ba_list
avg_probe_ba_list = pd.DataFrame(
data={'probe': multi_probe_list,
'probe_ba': probe_ba_list}).groupby('probe').mean()['probe_ba'].values.tolist()
return probe_ba_list, avg_probe_ba_list
def make_phrase_pps(self,
terms):
print('Making phrase_pps...')
terms = ['PERIOD'] + terms # to get pp value for very first term
num_terms = len(terms)
task_id = 0
pps = []
for n in range(num_terms):
term_ids = [self.terms.item_id_dict[term] for term in
terms[:n + 2]] # add to to compensate for 0index and y
window_mat = np.asarray(term_ids)[:, np.newaxis][-self.bptt_steps:].T
x, y = np.split(window_mat, [-1], axis=1)
x2 = np.tile(np.eye(GlobalConfigs.NUM_TASKS)[task_id], [1, x.shape[1], 1])
feed_dict = {self.graph.x: x, self.graph.x2: x2, self.graph.y: y}
pp = np.asscalar(self.sess.run(self.graph.pps, feed_dict=feed_dict))
pps.append(pp)
pps = pps[:-1] # compensate for PERIOD insertion
return pps
def init_distrib_idx(self, distrib, idx=None):
assert isinstance(distrib, DistribGauss)
x = distrib.get_mu()
if idx is None:
# initialize prior and thus average over all cases
mu = np.nanmean(x, axis=0, keepdims=True)
else:
# select cases idx
mu = x[idx, :]
idx_nan = np.isnan(mu)
if np.any(idx_nan):
# we need to randomly select new values for all NaNs
idx_good = np.ones_like(idx, dtype=bool)
idx_good[idx, :] = False
idx_good[np.isnan(x)] = False
x_good = x[idx_good, :]
num_nan = np.count_nonzero(idx_nan)
mu[idx_nan] = np.random.choice(x_good, num_nan, replace=False)
mu = np.copy(mu) # make sure to not overwrite data
std = np.empty_like(mu)
std.fill(np.asscalar(np.nanstd(x)))
self.init_data(mu, std)
def _police_move_by_continous_angle(self, police_list, police_actions):
# Accept continous move action, which is more suitable for MADDPG
# move angle (0~2pi)
police_actions = np.clip(police_actions, 0, 2*np.pi)
police_new_loc = police_list.copy()
police_speed = self.teams['police']['speed']
for _i, _a in enumerate(police_actions):
_a = np.asscalar(_a) # transform array to scalar
action_dir = np.array([np.cos(_a), np.sin(_a)])
police_dir = action_dir * police_speed
_p = police_list[_i]
_p = (_p[0] + police_dir[0], _p[1] + police_dir[1])
_p = self.ensure_inside(_p)
police_new_loc[_i] = _p
return police_new_loc
def load_h5_namedtuple(group, namedtuple):
""" Load a single namedtuple from an h5 group """
args = []
for field in namedtuple._fields:
try:
field_value = getattr(group, field).read()
if field_value.shape == ():
field_value = np.asscalar(field_value)
except tables.NoSuchNodeError:
try:
field_value = getattr(group._v_attrs, field)
except AttributeError:
field_value = None
args.append(field_value)
return namedtuple(*args)
def json_sanitize(data):
# This really doesn't make me happy. How many cases we we have to test?
if (type(data) == float) or (type(data) == numpy.float64):
# Handle floats specially
if math.isnan(data):
return "NaN";
if (data == float("+Inf")):
return "inf"
if (data == float("-Inf")):
return "-inf"
return data
elif hasattr(data, 'iterkeys'):
# Dictionary case
new_data = {}
for k in data.keys():
new_data[k] = json_sanitize(data[k])
return new_data
elif hasattr(data, '__iter__'):
# Anything else that looks like a list. N
new_data = []
for d in data:
new_data.append(json_sanitize(d))
return new_data
elif hasattr(data, 'shape') and data.shape == ():
# Numpy 0-d array
return np.asscalar(data)
else:
return data
def sin(Vo, Va, Freq=None, Td=0, Df=0, Phase=0, t=None):
"""
SIN provides a damped sinusoidal waveform in the form
Vo + Va * np.sin(2 * np.pi * Freq * t + Phase * (np.pi / 180))
The waveforms is:
* t < Td ==> Vo + Va * np.sin(Phase * (np.pi / 180))
* t > Td ==> Vo + Va * np.sin(2 * np.pi * Freq * (t - Td) + Phase * (np.pi / 180)) * np.exp(-(t - Td) * Df)
:param Vo: offset
:param Va: amplitude (peak) of the waveform
:param Freq: frequency (Hz)
:param Td: delay time (s)
:param Df: damping factor (1/s)
:param Phase: voltage phase (deg)
:param t: array with times where the function has to be evaluated
:return: the function values at times defined in t
"""
# check presence of time array
if t is None:
raise TypeError('Missing time array')
# check if t is scalar
if isinstance(t, (int, float)):
t = np.array([t])
# check presence of Freq
if Freq is None:
Freq = 1 / t[-1]
out = np.zeros_like(t)
out[t <= Td] = Vo + Va * np.sin(Phase * (np.pi / 180))
out[t > Td] = Vo + Va * np.sin(2 * np.pi * Freq * (t[t > Td] - Td) + Phase * (np.pi / 180)) * np.exp(-(t[t > Td] - Td) * Df)
# if input is scalar convert out to scalar too
if out.size == 1:
out = np.asscalar(out)
return out
def validate(self):
if np.asscalar(self.x_size.value) is None:
self.x_size.value = 5
def __read_str(self, numchars=1, utf=None):
"""
Read a string of a specific length.
This is compatible with python 2 and python 3.
"""
rawstr = np.asscalar(np.fromfile(self._fsrc,
dtype='S%s' % numchars, count=1))
if utf or (utf is None and PY_VER == 3):
return rawstr.decode('utf-8')
return rawstr
def __read_comment(self):
"""
Read a single comment.
The comment is stored as an Event in Segment 0, which is
specifically for comments.
----------------------
Returns an empty list.
The returned object is already added to the Block.
No ID number: always called from another method
"""
# float64 -- timestamp (number of days since dec 30th 1899)
time = np.fromfile(self._fsrc, dtype=np.double, count=1)[0]
# int16 -- length of next string
numchars1 = np.asscalar(np.fromfile(self._fsrc,
dtype=np.int16, count=1))
# char * numchars -- the one who sent the comment
sender = self.__read_str(numchars1)
# int16 -- length of next string
numchars2 = np.asscalar(np.fromfile(self._fsrc,
dtype=np.int16, count=1))
# char * numchars -- comment text
text = self.__read_str(numchars2, utf=False)
comment = Event(times=pq.Quantity(time, units=pq.d), labels=text,
sender=sender, file_origin=self._file_origin)
self._seg0.events.append(comment)
return []
def __read_str(self, numchars=1, utf=None):
"""
Read a string of a specific length.
This is compatible with python 2 and python 3.
"""
rawstr = np.asscalar(np.fromfile(self._fsrc,
dtype='S%s' % numchars, count=1))
if utf or (utf is None and PY_VER == 3):
return rawstr.decode('utf-8')
return rawstr
def __read_comment(self):
"""
Read a single comment.
The comment is stored as an Event in Segment 0, which is
specifically for comments.
----------------------
Returns an empty list.
The returned object is already added to the Block.
No ID number: always called from another method
"""
# float64 -- timestamp (number of days since dec 30th 1899)
time = np.fromfile(self._fsrc, dtype=np.double, count=1)[0]
# int16 -- length of next string
numchars1 = np.asscalar(np.fromfile(self._fsrc,
dtype=np.int16, count=1))
# char * numchars -- the one who sent the comment
sender = self.__read_str(numchars1)
# int16 -- length of next string
numchars2 = np.asscalar(np.fromfile(self._fsrc,
dtype=np.int16, count=1))
# char * numchars -- comment text
text = self.__read_str(numchars2, utf=False)
comment = Event(times=pq.Quantity(time, units=pq.d), labels=text,
sender=sender, file_origin=self._file_origin)
self._seg0.events.append(comment)
return []
def observe(self, y):
self.lastobservation = y
xa = self.xa[0:2:1,0:1:1]
Pa = self.Pa[0:2:1,0:2:1]
try:
X, Wm, Wc = sigmaPoints(xa, Pa)
except:
warnings.warn('Encountered a matrix that is not positive definite in the sigma points calculation at the observe step')
Pa = nearpd(Pa)
X, Wm, Wc = sigmaPoints(xa, Pa)
hX, self.predictedobservation, Pyy = \
unscentedTransform(X, Wm, Wc, self.ha)
self.predictedobservation = np.asscalar(self.predictedobservation)
Pyy = np.asscalar(Pyy)
self.innovcov = Pyy
x = self.xa[0,0]
Pxy = 0.
Pvy = 0.
M = np.shape(X)[1]
for j in range(0, M):
haImage = self.ha(X[:,j])
Pxy += Wc[j] * (X[0,j] - x) * (haImage - self.predictedobservation)
Pvy += Wc[j] * X[1,j] * haImage
Pa = np.array( ((Pxy,), (Pvy,), (0.,), (0.,)) )
K = Pa * (1./Pyy)
self.gain = K[0,0]
self.innov = y - self.predictedobservation
self.xa += K * self.innov
self.Pa -= np.dot(K, Pa.T)
self.loglikelihood += UnscentedKalmanFilter.MINUS_HALF_LN_2PI - .5 * (np.log(self.innovcov) + self.innov * self.innov / self.innovcov)
def format_time(ts):
res = []
for each in ts:
res.append(std_time.strftime("%H:%M.%S", std_time.localtime(np.asscalar(np.int32(each)))))
return res
def get_date_range(df, timestamp_colkey):
max_time = df[timestamp_colkey].max()
min_time = df[timestamp_colkey].min()
t_to = std_time.strftime("%d-%b-%Y", std_time.localtime(np.asscalar(np.int32(max_time))))
t_from = std_time.strftime("%d-%b-%Y", std_time.localtime(np.asscalar(np.int32(min_time))))
if t_to == t_from:
return t_to
return "{} - {}".format(t_from, t_to)
def generate_samples_marked(intensity, T, n):
U = intensity.dim
Sequences = []
inds = np.arange(U)
for i in range(n):
seq = []
t = 0
while True:
intens1 = intensity.getUpperBound(t,T,inds)
#print(intens1)
dt = np.random.exponential(1/sum(intens1))
#print(dt)
new_t = t + dt
#print(new_t)
if new_t > T:
break
intens2 = intensity.getValue(new_t, inds)
#print(intens2)
u = np.random.uniform()
if sum(intens2)/sum(intens1) > u:
#print(intens2)
x_sum = sum(intens2)
norm_i = [ x/x_sum for x in intens2]
#print(norm_i)
dim = np.nonzero(np.random.multinomial(1, norm_i))
seq.append([new_t, np.asscalar(dim[0])])
t = new_t
if len(seq)>1:
Sequences.append(seq)
return Sequences
def _send_output(self, output, timestamp, name):
"""Send pipeline outputs through the LSL or OSC stream.
NOT PER CHANNEL
Args:
output (scalar): output of the pipeline
timestamp (float): timestamp
"""
for out in self._output_threads:
if isinstance(out, str): # LSL outlet
raise NotImplementedError
# self._outlet.push_sample([output], timestamp=timestamp)
else: # OSC output stream
if USE_LIBLO:
if (np.array(output).size==1):
new_output = [('f', np.asscalar(output))]
message = Message('/{}'.format(name), *new_output)
else:
new_output = [('f', x) for x in output[:]]
message = Message('/{}'.format(name), *new_output)
# send(out, Bundle(timestamp, message))
send(out, message)
else:
raise NotImplementedError
# self._client.send_message(}{}'.format(name),output[:])
if self.verbose:
print('Output: {}'.format(output))
def label_to_idx(labels, label):
center_idx_bool = labels == label
return np.asscalar(np.where(center_idx_bool)[0]), center_idx_bool
def _process_video(filename, coder):
"""
Process a single video file using FFmpeg
Args
filename: path to the video file
coder: instance of ImageCoder to provide TensorFlow image coding utils.
Returns:
video_buffer: numpy array with the video frames
mask_buffer: activity mask of the video frames
frame_h: integer, video height in pixels.
frame_w: integer, width width in pixels.
seq_length: sequence length (non-zero frames)
"""
video, raw_h, raw_w, seq_length = coder.decode_video(filename)
video = video.astype(np.uint8)
assert len(video.shape) == 4
assert video.shape[3] == 3
frame_h, frame_w = video.shape[1], video.shape[2]
# generate mask from annotations
groups = filename.split('/')
annot_file_name = groups[-1].split('.')[0] + '.xgtf'
annot_file_path = os.path.join(FLAGS.annotation_directory, groups[-2], annot_file_name)
parsed_bbx = _parse_annotation_xml(annot_file_path)
if FLAGS.resize_h != -1:
parsed_bbx = _resize_bbx(parsed_bbx, raw_h, raw_w)
masks = _bbx_to_mask(parsed_bbx, seq_length, FLAGS.resize_h, FLAGS.resize_w)
encoded_frames_seq = []
encoded_masks_seq = []
for idx in range(seq_length):
encoded_frames_seq.append(coder.encode_frame(video[idx, :, :, :]))
encoded_masks_seq.append(coder.encode_mask(masks[idx, :, :, :]))
return encoded_frames_seq, encoded_masks_seq, frame_h, frame_w, np.asscalar(seq_length)
def _get_trial(root, combo):
path = get_path(root, combo)
mat = spio.loadmat(path)
data = mat['data'].astype(np.float32)
gesture = np.repeat(label_to_gesture(np.asscalar(mat['label'].astype(np.int))), len(data))
subject = np.repeat(np.asscalar(mat['subject'].astype(np.int)), len(data))
return Trial(data=data, gesture=gesture, subject=subject)
def assign_scalar(message, value):
"""
Adds the appropriate scalar type of value to the protobuf message
"""
if value is None:
message.null_val = True
elif isinstance(value, np.generic):
assign_scalar(message, np.asscalar(value))
elif isinstance(value, (str, six.text_type)):
message.string_val = value
elif isinstance(value, np.dtype):
message.dtype_val = dtype_to_protobuf(value)
elif isinstance(value, float):
message.double_val = value
elif isinstance(value, bool):
message.bool_val = value
elif isinstance(value, six.integer_types):
message.int_val = value
elif isinstance(value, slice):
slice_val = ops_pb.Slice()
if value.start is not None:
slice_val.start.value = value.start
if value.step is not None:
slice_val.step.value = value.step
if value.stop is not None:
slice_val.stop.value = value.stop
message.slice_val.CopyFrom(slice_val)
elif isinstance(value, dict):
for key in value:
assign_scalar(message.map_val.map[key], value[key])
# This encodes an empty dict for deserialization
assign_scalar(message.map_val.map['_ngraph_map_sentinel_'], '')
elif isinstance(value, Axis):
message.axis.CopyFrom(axis_to_protobuf(value))
elif isinstance(value, AxesMap):
message.axes_map.CopyFrom(axes_map_to_protobuf(value))
else:
raise unhandled_scalar_value(value)
def f(self, X, W):
"""Function value.
"""
X_ = list(X)
n = len(X_)
K = W[0].shape[1] # The number of components
f = 0.0
for k in range(K):
for i in range(n):
wik = W[i][:, [k]]
for j in range(n):
if self.pred_comp[i][j] > 0:
wjk = W[j][:, [k]]
ti = np.dot(X_[i], wik)
tj = np.dot(X_[j], wjk)
f += np.asscalar(np.dot(ti.T, tj))
# Deflate for next component
if k < K - 1: # Do not deflate for last component
for i in range(n):
wi = W[i][:, k]
ti = np.dot(X_[i], wi)
titi = np.asscalar(np.dot(ti.T, ti))
if titi > consts.TOLERANCE:
pi = np.dot(X_[i].T, ti) / titi
X_[i] = X_[i] - np.dot(ti, pi.T) # Deflate
# else:
# pi = np.zeros_like(wi)
return f
def compute_error(A_in, Ag_in):
A = A_in
Ag = Ag_in
#reallign
D = A.shape[1]
inner = np.zeros((D, D))
for i in range(D):
for j in range(D):
inner[i, j] = np.asscalar(A[:, i].transpose() * Ag[:, j] )/(norm(A[:, i]) * norm(Ag[:, j]))
max = np.argmax(inner, axis = 0)
P = np.asmatrix(np.zeros((D, D)))
for i in range(D):
P[i, max[i]] = 1
# print "normalize the rows of A and A^*"
inv_norm_A = np.asarray(1.0 / np.apply_along_axis(norm, 0, A))
A = A * np.diag(inv_norm_A)
inv_norm_Ag = np.asarray(1.0 / np.apply_along_axis(norm, 0, Ag))
Ag = Ag * np.diag(inv_norm_Ag)
u = np.asmatrix(np.ones((1, D)))
#for each A_i^* we try to find the A_i that is closest to A_i^*
error = 0
for i in range(D):
Ag_i = Ag[:, i]
inner_product = np.asmatrix(Ag_i.transpose() * A)
norm_A = np.asmatrix(np.diag(A.transpose() * A))
z = np.divide(inner_product, norm_A).transpose()
z = np.asarray(z).flatten().transpose()
scalar = np.diag(z)
As = A * scalar
diff = np.apply_along_axis(norm, 0, As - Ag_i * u)
# min_idx = np.argmin(diff)
# print 'for Ag_%d: A_%d' % (i, min_idx)
difmin = np.amin(diff)
difmin = difmin * difmin
error = error + difmin
return error
def mean(self,*,axis=1):
"""Returns the mean of each signal in AnalogSignalArray."""
try:
means = np.mean(self._ydata, axis=axis).squeeze()
if means.size == 1:
return np.asscalar(means)
return means
except IndexError:
raise IndexError("Empty AnalogSignalArray cannot calculate mean")