def rev(self, lng, lat, z=None, _type=np.int32):
if z is None:
z = self._default_z
if all(isinstance(var, (int, float, tuple)) for var in [lng, lat]):
lng, lat = (np.array([lng]), np.array([lat]))
if not all(isinstance(var, np.ndarray) for var in [lng, lat]):
raise ValueError("lng, lat inputs must be of type int, float, tuple or numpy.ndarray")
if not isinstance(z, np.ndarray):
z = np.zeros_like(lng) + z
coord = np.dstack([lng, lat, z])
offset, scale = np.vsplit(self._offscl, 2)
normed = coord * scale + offset
X = self._rpc(normed)
result = np.rollaxis(np.inner(self._A, X) / np.inner(self._B, X), 0, 3)
rev_offset, rev_scale = np.vsplit(self._px_offscl_rev, 2)
# needs to return x/y
return np.rollaxis(result * rev_scale + rev_offset, 2).squeeze().astype(_type)[::-1]
python类vsplit()的实例源码
def paint_latents( event ):
global r, Z, output,painted_rects,MASK,USER_MASK,RECON
# Get extent of latent paintbrush
x1, y1 = ( event.x - d.get() ), ( event.y - d.get() )
x2, y2 = ( event.x + d.get() ), ( event.y + d.get() )
selected_widget = event.widget
# Paint in latent space and update Z
painted_rects.append(event.widget.create_rectangle( x1, y1, x2, y2, fill = rb(color.get()),outline = rb(color.get()) ))
r[max((y1-bd),0):min((y2-bd),r.shape[0]),max((x1-bd),0):min((x2-bd),r.shape[1])] = color.get()/255.0;
Z = np.asarray([np.mean(o) for v in [np.hsplit(h,Z.shape[0])\
for h in np.vsplit((r),Z.shape[1])]\
for o in v]).reshape(Z.shape[0],Z.shape[1])
if SAMPLE_FLAG:
update_photo(None,output)
update_canvas(w) # Remove this if you wish to see a more free-form paintbrush
else:
DELTA = model.sample_at(np.float32([Z.flatten()]))[0]-to_tanh(np.float32(RECON))
MASK=scipy.ndimage.filters.gaussian_filter(np.min([np.mean(np.abs(DELTA),axis=0),np.ones((64,64))],axis=0),0.7)
# D = dampen(to_tanh(np.float32(RECON)),MASK*DELTA+(1-MASK)*ERROR)
D = MASK*DELTA+(1-MASK)*ERROR
IM = np.uint8(from_tanh(to_tanh(RECON)+D))
update_canvas(w) # Remove this if you wish to see a more free-form paintbrush
update_photo(IM,output)
# Scroll to lighten or darken an image patch
def test_nested_model_void(self):
from l1l2py import tools
data, test_data = np.vsplit(self.X, 2)
labels, test_labels = np.hsplit(self.Y, 2)
tau_opt, lambda_opt = (50.0, 0.1)
mu_range = np.linspace(0.1, 1.0, 10)
assert_raises(
ValueError, nested_models,
data, labels, test_data, test_labels,
mu_range, tau_opt, lambda_opt,
error_function=tools.regression_error,
data_normalizer=tools.standardize,
labels_normalizer=tools.center)
def get_next_sample(self):
if self.incomplete_samples_ is not None:
assert self.incomplete_samples_.size > 0
split = np.vsplit(self.incomplete_samples_, [1])
assert len(split) == 2
next_sample = split[0]
if split[1].size == 0:
self.incomplete_samples_ = None
else:
self.incomplete_samples_ = split[1]
return next_sample.ravel()
else:
return None
def deleteRow(self, row_number, data):
first, deleted, second = np.vsplit(data, [row_number, row_number + 1])
return np.vstack((first, second))
def load_csv(self):
file_name = "data/jra_race_resultNN.csv"
df = pd.read_csv(file_name)
## ???????
labelEncoder = preprocessing.LabelEncoder()
df['area_name'] = labelEncoder.fit_transform(df['area_name'])
df['race_name'] = labelEncoder.fit_transform(df['race_name'])
df['track'] = labelEncoder.fit_transform(df['track'])
df['run_direction'] = labelEncoder.fit_transform(df['run_direction'])
df['track_condition'] = labelEncoder.fit_transform(df['track_condition'])
df['horse_name'] = labelEncoder.fit_transform(df['horse_name'])
df['horse_sex'] = labelEncoder.fit_transform(df['horse_sex'])
df['jockey_name'] = labelEncoder.fit_transform(df['jockey_name'])
df['margin'] = labelEncoder.fit_transform(df['margin'])
df['is_blinkers'] = labelEncoder.fit_transform(df['is_blinkers'])
df['trainer_name'] = labelEncoder.fit_transform(df['trainer_name'])
df['comments_by_trainer'] = labelEncoder.fit_transform(df['comments_by_trainer'])
df['evaluation_by_trainer'] = labelEncoder.fit_transform(df['evaluation_by_trainer'])
df['dhorse_weight'] = labelEncoder.fit_transform(df['dhorse_weight'])
x_np = np.array(df[['area_name', 'race_number', 'race_name', 'track', 'run_direction',
'distance', 'track_condition', 'purse', 'heads_count',
'post_position', 'horse_number', 'horse_name', 'horse_sex', 'horse_age',
'jockey_name', 'time', 'margin', 'time3F',
'load_weight', 'horse_weight', 'dhorse_weight', 'odds_order',
'odds', 'is_blinkers', 'trainer_name', 'comments_by_trainer',
'evaluation_by_trainer'
]].fillna(0))
# ??
d = df[['finish_order']].to_dict('record')
self.vectorizer = DictVectorizer(sparse=False)
y_np = self.vectorizer.fit_transform(d)
self.n_classes = len(self.vectorizer.get_feature_names())
self.train_size = int(len(df[['finish_order']]) / 5)
self.batch_size = self.train_size
# ????????????????????
[self.x_train, self.x_test] = np.vsplit(x_np, [self.train_size])
[self.y_train, self.y_test] = np.vsplit(y_np, [self.train_size])
# Create model
def omega_output(self, fname, parameters):
"""This method writes the dispersion relation to the file fname.
:param fname: Filename
:type fname: string
:param parameters: Array containing the parameters.
:type parameters: numpy.ndarray
"""
omega = self.omega(parameters)
kappa = self.kappamesh
kmesh = self.kmesh
k = self.k
#print(omega, self.dks)
vgs = np.gradient(omega, *self.dks, edge_order=2)
vg = np.sqrt(sum(vgc**2 for vgc in vgs))
if self.dim==2:
vg[:3,:3] = 1
elif self.dim==3:
vg[:3,:3,:3] = 1
vph = omega/k
vph.ravel()[0] = 1.
data = [*np.broadcast_arrays(*kappa), k, omega, vph, vg, *vgs]
data = np.broadcast_arrays(*data)
blocks = zip(*map(lambda x: np.vsplit(x, x.shape[0]), data))
with open(fname, 'wb') as f:
kappanames = ' '.join(['kx', 'ky', 'kz'][:len(kappa)])
vgsnames = ' '.join(['vgx', 'vgy', 'vgz'][:len(vgs)])
f.write(('#' + kappanames + ' k omega vph vg ' + vgsnames + '\n').encode('us-ascii'))
for block_columns in blocks:
np.savetxt(f, np.vstack(map(np.ravel, block_columns)).T)
f.write(b'\n')
def gen_task_mbs(self, style, test_fold_id):
num_task_iterations = int(''.join([c for c in self.regime if c.isdigit()]))
# make blocks
if style == 'train':
task_lines = list(chain(*[fold for n, fold in enumerate(self.task_folds)
if n != test_fold_id]))
windows_x, windows_y = self.make_windows(task_lines)
block_x = np.tile(windows_x, [num_task_iterations, 1])
block_y = np.tile(windows_y, [num_task_iterations, 1])
elif style == 'test':
task_lines = list(chain(*[fold for n, fold in enumerate(self.task_folds)
if n == test_fold_id]))
windows_x, windows_y = self.make_windows(task_lines)
block_x = windows_x
block_y = windows_y
elif style == 'train1':
task_lines = list(chain(*[fold for n, fold in enumerate(self.task_folds)
if n != test_fold_id]))
windows_x, windows_y = self.make_windows(task_lines)
block_x = windows_x
block_y = windows_y
else:
raise AttributeError('rnnlab: Invalid arg to "style"')
# split to mbs
if not gcd(self.mb_size, len(block_x)) == self.mb_size:
raise Exception(
'rnnlab: Number of task_lines must be divisible by mb_size')
num_splits = len(block_x) // self.mb_size
# generate
for x, y in zip(np.vsplit(block_x, num_splits),
np.vsplit(block_y, num_splits)):
yield x, y
def batch_gen(self,
num_iterations=None):
if not num_iterations:
num_iterations = self.num_iterations
# batch
for n, term_id_doc in enumerate(self.docs):
windows_mat = self.make_windows_mat(term_id_doc)
windows_mat_x, windows_mat_y = np.split(windows_mat, [self.bptt_steps], axis=1)
for _ in range(num_iterations):
for x, y in zip(np.vsplit(windows_mat_x, self.num_mbs_in_doc),
np.vsplit(windows_mat_y, self.num_mbs_in_doc)):
yield x, y
def _split_array(image):
"""Splits an image into 16x16 sized tiles.
Returns a list of arrays.
"""
tiles = []
dims = image.shape
split_image = np.vsplit(image, int(dims[0]/16))
for tile in split_image:
tiles.extend(np.hsplit(tile, int(dims[1]/16)))
return tiles
#Currently for 16x16 tiles only
def _least_square_evoked(data, events, event_id, tmin, tmax, sfreq):
"""Least square estimation of evoked response from data.
Parameters
----------
data : ndarray, shape (n_channels, n_times)
The data to estimates evoked
events : ndarray, shape (n_events, 3)
The events typically returned by the read_events function.
If some events don't match the events of interest as specified
by event_id, they will be ignored.
event_id : dict
The id of the events to consider
tmin : float
Start time before event.
tmax : float
End time after event.
sfreq : float
Sampling frequency.
Returns
-------
evokeds_data : dict of ndarray
A dict of evoked data for each event type in event_id.
toeplitz : dict of ndarray
A dict of toeplitz matrix for each event type in event_id.
"""
nmin = int(tmin * sfreq)
nmax = int(tmax * sfreq)
window = nmax - nmin
n_samples = data.shape[1]
toeplitz_mat = dict()
full_toep = list()
for eid in event_id:
# select events by type
ix_ev = events[:, -1] == event_id[eid]
# build toeplitz matrix
trig = np.zeros((n_samples, 1))
ix_trig = (events[ix_ev, 0]) + nmin
trig[ix_trig] = 1
toep_mat = linalg.toeplitz(trig[0:window], trig)
toeplitz_mat[eid] = toep_mat
full_toep.append(toep_mat)
# Concatenate toeplitz
full_toep = np.concatenate(full_toep)
# least square estimation
predictor = np.dot(linalg.pinv(np.dot(full_toep, full_toep.T)), full_toep)
all_evokeds = np.dot(predictor, data.T)
all_evokeds = np.vsplit(all_evokeds, len(event_id))
# parse evoked response
evoked_data = dict()
for idx, eid in enumerate(event_id):
evoked_data[eid] = all_evokeds[idx].T
return evoked_data, toeplitz_mat
